diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 4f30a87..d07ed28 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -34,7 +34,7 @@ jobs: id: set-matrix run: | # List of all available parsers - ALL_PARSERS="redshift postgresql cql snowflake tsql doris trino plsql" + ALL_PARSERS="redshift postgresql cql snowflake tsql doris trino plsql googlesql" # Add more parsers here as they are added to the repository # ALL_PARSERS="redshift mysql postgresql" diff --git a/googlesql/GoogleSQLLexer.g4 b/googlesql/GoogleSQLLexer.g4 new file mode 100644 index 0000000..635d808 --- /dev/null +++ b/googlesql/GoogleSQLLexer.g4 @@ -0,0 +1,497 @@ +lexer grammar GoogleSQLLexer; + +options { + caseInsensitive = true; +} + +fragment A: [a]; +fragment B: [b]; +fragment C: [c]; +fragment D: [d]; +fragment E: [e]; +fragment F: [f]; +fragment G: [g]; +fragment H: [h]; +fragment I: [i]; +fragment J: [j]; +fragment K: [k]; +fragment L: [l]; +fragment M: [m]; +fragment N: [n]; +fragment O: [o]; +fragment P: [p]; +fragment Q: [q]; +fragment R: [r]; +fragment S: [s]; +fragment T: [t]; +fragment U: [u]; +fragment V: [v]; +fragment W: [w]; +fragment X: [x]; +fragment Y: [y]; +fragment Z: [z]; + +EQUAL_OPERATOR: '='; +NOT_EQUAL_OPERATOR: '!='; +NOT_EQUAL2_OPERATOR: '<>'; +LT_OPERATOR: '<'; +LE_OPERATOR: '<='; +GT_OPERATOR: '>'; +GE_OPERATOR: '>='; +KL_OPERATOR: '<<'; +KR_OPERATOR: '>>'; +PLUS_OPERATOR: '+'; +MINUS_OPERATOR: '-'; +MULTIPLY_OPERATOR: '*'; +DIVIDE_OPERATOR: '/'; +BITWISE_NOT_OPERATOR: '~'; +EXCLAMATION_OPERATOR: '!'; +MODULO_OPERATOR: '%'; + +COMMA_SYMBOL: ','; +DOT_SYMBOL: '.'; +LC_BRACKET_SYMBOL: '{'; +RC_BRACKET_SYMBOL: '}'; +LR_BRACKET_SYMBOL: '('; +RR_BRACKET_SYMBOL: ')'; +LS_BRACKET_SYMBOL: '['; +RS_BRACKET_SYMBOL: ']'; +STROKE_SYMBOL: '|'; +COLON_SYMBOL: ':'; +SEMI_SYMBOL: ';'; +SINGLE_QUOTE_SYMBOL: '\''; +SINGLE_QUOTE_3_SYMBOL: '\'\'\''; +DOUBLE_QUOTE_SYMBOL: '"'; +DOUBLE_QUOTE_3_SYMBOL: '"""'; +BACKQUOTE_SYMBOL: '`'; +QUESTION_SYMBOL: '?'; +AT_SYMBOL: '@'; +ATAT_SYMBOL: '@@'; +EQUAL_GT_BRACKET_SYMBOL: '=>'; +SUB_GT_BRACKET_SYMBOL: '->'; +PLUS_EQUAL_SYMBOL: '+='; +SUB_EQUAL_SYMBOL: '-='; +PIPE_SYMBOL: '|>'; +CIRCUMFLEX_SYMBOL: '^'; +BIT_AND_SYMBOL: '&'; +BOOL_OR_SYMBOL: '||'; + +fragment ANY_ESCAPE: + '\\' . + | '\\' '\n' + | '\\' '\r' + | '\\' '\r' '\n'; +fragment NO_BACKSLASH_SINGLE_QUOTE_NEWLINE: ~['\n\r\\]; +fragment NO_BACKSLASH_DOUBLE_QUOTE_NEWLINE: ~["\n\r\\]; +fragment NO_BACKSLASH_SINGLE_QUOTE: ~['\\]; +fragment NO_BACKSLASH_DOUBLE_QUOTE: ~["\\]; + +// Strings and bytes, comes from https://github.com/google/zetasql/blob/194cd32b5d766d60e3ca442651d792c7fe54ea74/zetasql/parser/flex_tokenizer.l#L112 +fragment SQTEXT_0: + SINGLE_QUOTE_SYMBOL ( + NO_BACKSLASH_SINGLE_QUOTE_NEWLINE + | ANY_ESCAPE + )*; +fragment SQTEXT: SQTEXT_0 SINGLE_QUOTE_SYMBOL; +fragment DQTEXT_0: + DOUBLE_QUOTE_SYMBOL ( + NO_BACKSLASH_DOUBLE_QUOTE_NEWLINE + | ANY_ESCAPE + )*; +fragment DQTEXT: DQTEXT_0 DOUBLE_QUOTE_SYMBOL; +fragment SQ3TEXT_0: + SINGLE_QUOTE_3_SYMBOL ( + (SINGLE_QUOTE_SYMBOL SINGLE_QUOTE_SYMBOL?)? ( + NO_BACKSLASH_SINGLE_QUOTE + | ANY_ESCAPE + ) + )*; +fragment SQ3TEXT: SQ3TEXT_0 SINGLE_QUOTE_3_SYMBOL; + +fragment DQ3TEXT_0: + DOUBLE_QUOTE_3_SYMBOL ( + (DOUBLE_QUOTE_SYMBOL DOUBLE_QUOTE_SYMBOL?)? ( + NO_BACKSLASH_DOUBLE_QUOTE + | ANY_ESCAPE + ) + )*; +fragment DQ3TEXT: DQ3TEXT_0 DOUBLE_QUOTE_3_SYMBOL; + +// String literal +STRING_LITERAL: R? ( SQTEXT | DQTEXT | SQ3TEXT | DQ3TEXT); + +// Bytes literal +BYTES_LITERAL: (B | R B | B R) ( + SQTEXT + | DQTEXT + | SQ3TEXT + | DQ3TEXT + ); + +UNCLOSED_STRING_LITERAL: (SQTEXT_0 | DQTEXT_0); + +UNCLOSED_TRIPLE_QUOTED_STRING_LITERAL: (SQ3TEXT_0 | DQ3TEXT_0); + +UNCLOSED_RAW_STRING_LITERAL: R (SQTEXT_0 | DQTEXT_0); + +UNCLOSED_TRIPLE_QUOTED_RAW_STRING_LITERAL: + R (SQ3TEXT_0 | DQ3TEXT_0); + +UNCLOSED_BYTES_LITERAL: B (SQTEXT_0 | DQTEXT_0); + +UNCLOSED_TRIPLE_QUOTED_BYTES_LITERAL: B (SQ3TEXT_0 | DQ3TEXT_0); + +UNCLOSED_RAW_BYTES_LITERAL: (R B | B R) (SQTEXT_0 | DQTEXT_0); + +UNCLOSED_TRIPLE_QUOTED_RAW_BYTES_LITERAL: (R B | B R) ( + SQ3TEXT_0 + | DQ3TEXT_0 + ); + +FLOATING_POINT_LITERAL: (PLUS_OPERATOR | MINUS_OPERATOR)? DECIMAL_DIGITS DOT_SYMBOL DECIMAL_DIGITS? + ( + 'E' (PLUS_OPERATOR | MINUS_OPERATOR)? DECIMAL_DIGITS + )? + | (PLUS_OPERATOR | MINUS_OPERATOR)? DECIMAL_DIGITS? DOT_SYMBOL DECIMAL_DIGITS ( + 'E' (PLUS_OPERATOR | MINUS_OPERATOR)? DECIMAL_DIGITS + )? + | DECIMAL_DIGITS 'E' (PLUS_OPERATOR | MINUS_OPERATOR)? DECIMAL_DIGITS; + +INTEGER_LITERAL: DECIMAL_DIGITS | HEX_DIGITS; +fragment DECIMAL_DIGIT: [0-9]; +fragment HEX_DIGIT: [0-9a-f]; +fragment DECIMAL_DIGITS: DECIMAL_DIGIT+; +fragment HEX_DIGITS: '0x' HEX_DIGIT+; + +ARRAY_SYMBOL: 'ARRAY'; +ALL_SYMBOL: 'ALL'; +AS_SYMBOL: 'AS'; +ASC_SYMBOL: 'ASC'; +BY_SYMBOL: 'BY'; +CROSS_SYMBOL: 'CROSS'; +JOIN_SYMBOL: 'JOIN'; +DELTA_SYMBOL: 'DELTA'; +DESC_SYMBOL: 'DESC'; +DIFFERENTIAL_PRIVACY_SYMBOL: 'DIFFERENTIAL_PRIVACY'; +DISTINCT_SYMBOL: 'DISTINCT'; +EPSILON_SYMBOL: 'EPSILON'; +EXCEPT_SYMBOL: 'EXCEPT'; +EXCLUDE_SYMBOL: 'EXCLUDE'; +FOR_SYMBOL: 'FOR'; +FROM_SYMBOL: 'FROM'; +FULL_SYMBOL: 'FULL'; +IN_SYMBOL: 'IN'; +INCLUDE_SYMBOL: 'INCLUDE'; +INNER_SYMBOL: 'INNER'; +INTERSECT_SYMBOL: 'INTERSECT'; +LEFT_SYMBOL: 'LEFT'; +LIMIT_SYMBOL: 'LIMIT'; +MAX_GROUPS_CONTRIBUTED_SYMBOL: 'MAX_GROUPS_CONTRIBUTED'; +NULL_SYMBOL: 'NULL'; +NULLS_SYMBOL: 'NULLS'; +OF_SYMBOL: 'OF'; +OFFSET_SYMBOL: 'OFFSET'; +ON_SYMBOL: 'ON'; +OPTIONS_SYMBOL: 'OPTIONS'; +ORDER_SYMBOL: 'ORDER'; +OUTER_SYMBOL: 'OUTER'; +PERCENT_SYMBOL: 'PERCENT'; +PIVOT_SYMBOL: 'PIVOT'; +PRIVACY_UNIT_COLUMN_SYMBOL: 'PRIVACY_UNIT_COLUMN'; +RIGHT_SYMBOL: 'RIGHT'; +RECURSIVE_SYMBOL: 'RECURSIVE'; +REPLACE_SYMBOL: 'REPLACE'; +UNPIVOT_SYMBOL: 'UNPIVOT'; +SELECT_SYMBOL: 'SELECT'; +STRUCT_SYMBOL: 'STRUCT'; +SYSTEM_SYMBOL: 'SYSTEM'; +SYSTEM_TIME_SYMBOL: 'SYSTEM_TIME'; +TABLESAMPLE_SYMBOL: 'TABLESAMPLE'; +UNION_SYMBOL: 'UNION'; +UNNEST_SYMBOL: 'UNNEST'; +USING_SYMBOL: 'USING'; +VALUE_SYMBOL: 'VALUE'; +WITH_SYMBOL: 'WITH'; +TRUE_SYMBOL: 'TRUE'; +FALSE_SYMBOL: 'FALSE'; +NUMERIC_SYMBOL: 'NUMERIC'; +DECIMAL_SYMBOL: 'DECIMAL'; +BIGNUMERIC_SYMBOL: 'BIGNUMERIC'; +BIGDECIMAL_SYMBOL: 'BIGDECIMAL'; +NOT_SYMBOL: 'NOT'; +AND_SYMBOL: 'AND'; +OR_SYMBOL: 'OR'; +JSON_SYMBOL: 'JSON'; +DATE_SYMBOL: 'DATE'; +TIME_SYMBOL: 'TIME'; +DATETIME_SYMBOL: 'DATETIME'; +TIMESTAMP_SYMBOL: 'TIMESTAMP'; +RANGE_SYMBOL: 'RANGE'; +INTERVAL_SYMBOL: 'INTERVAL'; +SIMPLE_SYMBOL: 'SIMPLE'; +ABORT_SYMBOL: 'ABORT'; +ACCESS_SYMBOL: 'ACCESS'; +ACTION_SYMBOL: 'ACTION'; +AGGREGATE_SYMBOL: 'AGGREGATE'; +ADD_SYMBOL: 'ADD'; +ALTER_SYMBOL: 'ALTER'; +ALWAYS_SYMBOL: 'ALWAYS'; +ANALYZE_SYMBOL: 'ANALYZE'; +APPROX_SYMBOL: 'APPROX'; +ARE_SYMBOL: 'ARE'; +ASSERT_SYMBOL: 'ASSERT'; +BATCH_SYMBOL: 'BATCH'; +BEGIN_SYMBOL: 'BEGIN'; +BREAK_SYMBOL: 'BREAK'; +CALL_SYMBOL: 'CALL'; +CASCADE_SYMBOL: 'CASCADE'; +CHECK_SYMBOL: 'CHECK'; +CLAMPED_SYMBOL: 'CLAMPED'; +CLONE_SYMBOL: 'CLONE'; +COPY_SYMBOL: 'COPY'; +CLUSTER_SYMBOL: 'CLUSTER'; +COLUMN_SYMBOL: 'COLUMN'; +COLUMNS_SYMBOL: 'COLUMNS'; +COMMIT_SYMBOL: 'COMMIT'; +CONNECTION_SYMBOL: 'CONNECTION'; +CONSTANT_SYMBOL: 'CONSTANT'; +CONSTRAINT_SYMBOL: 'CONSTRAINT'; +CONTINUE_SYMBOL: 'CONTINUE'; +CORRESPONDING_SYMBOL: 'CORRESPONDING'; +CYCLE_SYMBOL: 'CYCLE'; +DATA_SYMBOL: 'DATA'; +DATABASE_SYMBOL: 'DATABASE'; +DECLARE_SYMBOL: 'DECLARE'; +DEFINER_SYMBOL: 'DEFINER'; +DELETE_SYMBOL: 'DELETE'; +DELETION_SYMBOL: 'DELETION'; +DEPTH_SYMBOL: 'DEPTH'; +DESCRIBE_SYMBOL: 'DESCRIBE'; +DETERMINISTIC_SYMBOL: 'DETERMINISTIC'; +DO_SYMBOL: 'DO'; +DROP_SYMBOL: 'DROP'; +ELSEIF_SYMBOL: 'ELSEIF'; +ENFORCED_SYMBOL: 'ENFORCED'; +ERROR_SYMBOL: 'ERROR'; +EXCEPTION_SYMBOL: 'EXCEPTION'; +EXECUTE_SYMBOL: 'EXECUTE'; +EXPLAIN_SYMBOL: 'EXPLAIN'; +EXPORT_SYMBOL: 'EXPORT'; +EXTEND_SYMBOL: 'EXTEND'; +EXTERNAL_SYMBOL: 'EXTERNAL'; +FILES_SYMBOL: 'FILES'; +FILTER_SYMBOL: 'FILTER'; +FILL_SYMBOL: 'FILL'; +FIRST_SYMBOL: 'FIRST'; +FOREIGN_SYMBOL: 'FOREIGN'; +FORMAT_SYMBOL: 'FORMAT'; +FUNCTION_SYMBOL: 'FUNCTION'; +GENERATED_SYMBOL: 'GENERATED'; +GRANT_SYMBOL: 'GRANT'; +GROUP_ROWS_SYMBOL: 'GROUP_ROWS'; +HIDDEN_SYMBOL: 'HIDDEN'; +IDENTITY_SYMBOL: 'IDENTITY'; +IMMEDIATE_SYMBOL: 'IMMEDIATE'; +IMMUTABLE_SYMBOL: 'IMMUTABLE'; +IMPORT_SYMBOL: 'IMPORT'; +INCREMENT_SYMBOL: 'INCREMENT'; +INDEX_SYMBOL: 'INDEX'; +INOUT_SYMBOL: 'INOUT'; +INPUT_SYMBOL: 'INPUT'; +INSERT_SYMBOL: 'INSERT'; +INVOKER_SYMBOL: 'INVOKER'; +ISOLATION_SYMBOL: 'ISOLATION'; +ITERATE_SYMBOL: 'ITERATE'; +KEY_SYMBOL: 'KEY'; +LANGUAGE_SYMBOL: 'LANGUAGE'; +LAST_SYMBOL: 'LAST'; +LEAVE_SYMBOL: 'LEAVE'; +LEVEL_SYMBOL: 'LEVEL'; +LOAD_SYMBOL: 'LOAD'; +LOOP_SYMBOL: 'LOOP'; +MACRO_SYMBOL: 'MACRO'; +MAP_SYMBOL: 'MAP'; +MATCH_SYMBOL: 'MATCH'; +KW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL: + 'KW_MATCH_RECOGNIZE_NONRESERVED'; +MATCHED_SYMBOL: 'MATCHED'; +MATERIALIZED_SYMBOL: 'MATERIALIZED'; +MAX_SYMBOL: 'MAX'; +MAXVALUE_SYMBOL: 'MAXVALUE'; +MEASURES_SYMBOL: 'MEASURES'; +MESSAGE_SYMBOL: 'MESSAGE'; +METADATA_SYMBOL: 'METADATA'; +MIN_SYMBOL: 'MIN'; +MINVALUE_SYMBOL: 'MINVALUE'; +MODEL_SYMBOL: 'MODEL'; +MODULE_SYMBOL: 'MODULE'; +ONLY_SYMBOL: 'ONLY'; +OUT_SYMBOL: 'OUT'; +OUTPUT_SYMBOL: 'OUTPUT'; +OVERWRITE_SYMBOL: 'OVERWRITE'; +PARTITIONS_SYMBOL: 'PARTITIONS'; +PATTERN_SYMBOL: 'PATTERN'; +POLICIES_SYMBOL: 'POLICIES'; +POLICY_SYMBOL: 'POLICY'; +PRIMARY_SYMBOL: 'PRIMARY'; +PRIVATE_SYMBOL: 'PRIVATE'; +PRIVILEGE_SYMBOL: 'PRIVILEGE'; +PRIVILEGES_SYMBOL: 'PRIVILEGES'; +PROCEDURE_SYMBOL: 'PROCEDURE'; +PROJECT_SYMBOL: 'PROJECT'; +PUBLIC_SYMBOL: 'PUBLIC'; +RAISE_SYMBOL: 'RAISE'; +READ_SYMBOL: 'READ'; +REFERENCES_SYMBOL: 'REFERENCES'; +REMOTE_SYMBOL: 'REMOTE'; +REMOVE_SYMBOL: 'REMOVE'; +RENAME_SYMBOL: 'RENAME'; +REPEAT_SYMBOL: 'REPEAT'; +REPEATABLE_SYMBOL: 'REPEATABLE'; +REPLACE_FIELDS_SYMBOL: 'REPLACE_FIELDS'; +REPLICA_SYMBOL: 'REPLICA'; +REPORT_SYMBOL: 'REPORT'; +RESTRICT_SYMBOL: 'RESTRICT'; +RESTRICTION_SYMBOL: 'RESTRICTION'; +RETURNS_SYMBOL: 'RETURNS'; +RETURN_SYMBOL: 'RETURN'; +REVOKE_SYMBOL: 'REVOKE'; +ROLLBACK_SYMBOL: 'ROLLBACK'; +ROW_SYMBOL: 'ROW'; +RUN_SYMBOL: 'RUN'; +SAFE_CAST_SYMBOL: 'SAFE_CAST'; +SCHEMA_SYMBOL: 'SCHEMA'; +SEARCH_SYMBOL: 'SEARCH'; +SECURITY_SYMBOL: 'SECURITY'; +SEQUENCE_SYMBOL: 'SEQUENCE'; +SETS_SYMBOL: 'SETS'; +SET_SYMBOL: 'SET'; +SHOW_SYMBOL: 'SHOW'; +SNAPSHOT_SYMBOL: 'SNAPSHOT'; +SOURCE_SYMBOL: 'SOURCE'; +SQL_SYMBOL: 'SQL'; +STABLE_SYMBOL: 'STABLE'; +START_SYMBOL: 'START'; +STATIC_DESCRIBE_SYMBOL: 'STATIC_DESCRIBE'; +STORED_SYMBOL: 'STORED'; +STORING_SYMBOL: 'STORING'; +STRICT_SYMBOL: 'STRICT'; +TABLE_SYMBOL: 'TABLE'; +TABLES_SYMBOL: 'TABLES'; +TARGET_SYMBOL: 'TARGET'; +TEMP_SYMBOL: 'TEMP'; +TEMPORARY_SYMBOL: 'TEMPORARY'; +TRANSACTION_SYMBOL: 'TRANSACTION'; +TRANSFORM_SYMBOL: 'TRANSFORM'; +TRUNCATE_SYMBOL: 'TRUNCATE'; +TYPE_SYMBOL: 'TYPE'; +UNDROP_SYMBOL: 'UNDROP'; +UNIQUE_SYMBOL: 'UNIQUE'; +UNKNOWN_SYMBOL: 'UNKNOWN'; +UNTIL_SYMBOL: 'UNTIL'; +UPDATE_SYMBOL: 'UPDATE'; +VALUES_SYMBOL: 'VALUES'; +VECTOR_SYMBOL: 'VECTOR'; +VIEW_SYMBOL: 'VIEW'; +VIEWS_SYMBOL: 'VIEWS'; +VOLATILE_SYMBOL: 'VOLATILE'; +WEIGHT_SYMBOL: 'WEIGHT'; +WHILE_SYMBOL: 'WHILE'; +WRITE_SYMBOL: 'WRITE'; +ZONE_SYMBOL: 'ZONE'; +DESCRIPTOR_SYMBOL: 'DESCRIPTOR'; +INTERLEAVE_SYMBOL: 'INTERLEAVE'; +NULL_FILTERED_SYMBOL: 'NULL_FILTERED'; +PARENT_SYMBOL: 'PARENT'; +NEW_SYMBOL: 'NEW'; +END_SYMBOL: 'END'; +CASE_SYMBOL: 'CASE'; +WHEN_SYMBOL: 'WHEN'; +THEN_SYMBOL: 'THEN'; +ELSE_SYMBOL: 'ELSE'; +CAST_SYMBOL: 'CAST'; +EXTRACT_SYMBOL: 'EXTRACT'; +COLLATE_SYMBOL: 'COLLATE'; +IF_SYMBOL: 'IF'; +GROUPING_SYMBOL: 'GROUPING'; +HAVING_SYMBOL: 'HAVING'; +GROUP_SYMBOL: 'GROUP'; +ROLLUP_SYMBOL: 'ROLLUP'; +CUBE_SYMBOL: 'CUBE'; +HASH_SYMBOL: 'HASH'; +PROTO_SYMBOL: 'PROTO'; +PARTITION_SYMBOL: 'PARTITION'; +IGNORE_SYMBOL: 'IGNORE'; +RESPECT_SYMBOL: 'RESPECT'; +ROWS_SYMBOL: 'ROWS'; +OVER_SYMBOL: 'OVER'; +BETWEEN_SYMBOL: 'BETWEEN'; +UNBOUNDED_SYMBOL: 'UNBOUNDED'; +CURRENT_SYMBOL: 'CURRENT'; +PRECEDING_SYMBOL: 'PRECEDING'; +FOLLOWING_SYMBOL: 'FOLLOWING'; +NATURAL_SYMBOL: 'NATURAL'; +QUALIFY_SYMBOL: 'QUALIFY'; +DEFAULT_SYMBOL: 'DEFAULT'; +SLASH_SYMBOL: 'SLASH'; +MATCH_RECOGNIZE_SYMBOL: 'MATCH_RECOGNIZE'; +DEFINE_SYMBOL: 'DEFINE'; +LOOKUP_SYMBOL: 'LOOKUP'; +WHERE_SYMBOL: 'WHERE'; +WINDOW_SYMBOL: 'WINDOW'; +TO_SYMBOL: 'TO'; +EXISTS_SYMBOL: 'EXISTS'; +ANY_SYMBOL: 'ANY'; +SOME_SYMBOL: 'SOME'; +LIKE_SYMBOL: 'LIKE'; +IS_SYMBOL: 'IS'; +NO_SYMBOL: 'NO'; +INTO_SYMBOL: 'INTO'; +ASSERT_ROWS_MODIFIED_SYMBOL: 'ASSERT_ROWS_MODIFIED'; +CONFLICT_SYMBOL: 'CONFLICT'; +NOTHING_SYMBOL: 'NOTHING'; +MERGE_SYMBOL: 'MERGE'; +CREATE_SYMBOL: 'CREATE'; +ENUM_SYMBOL: 'ENUM'; +DESTINATION_SYMBOL: 'DESTINATION'; +PROPERTY_SYMBOL: 'PROPERTY'; +GRAPH_SYMBOL: 'GRAPH'; +NODE_SYMBOL: 'NODE'; +PROPERTIES_SYMBOL: 'PROPERTIES'; +LABEL_SYMBOL: 'LABEL'; +EDGE_SYMBOL: 'EDGE'; +NEXT_SYMBOL: 'NEXT'; +ASCENDING_SYMBOL: 'ASCENDING'; +DESCENDING_SYMBOL: 'DESCENDING'; +SKIP_SYMBOL: 'SKIP'; +SHORTEST_SYMBOL: 'SHORTEST'; +PATH_SYMBOL: 'PATH'; +PATHS_SYMBOL: 'PATHS'; +WALK_SYMBOL: 'WALK'; +TRAIL_SYMBOL: 'TRAIL'; +ACYCLIC_SYMBOL: 'ACYCLIC'; +OPTIONAL_SYMBOL: 'OPTIONAL'; +LET_SYMBOL: 'LET'; + +/* Identifiers: */ +fragment EXPONENT_WITHOUT_SIGN: E [0-9]+; +fragment UNQUOTED_IDENTIFIER: [A-Z_][A-Z0-9_]*; +fragment BQTEXT_0: + BACKQUOTE_SYMBOL ((~[\\`\r\n]) | (ANY_ESCAPE))*; +fragment BQTEXT: BQTEXT_0 BACKQUOTE_SYMBOL; +IDENTIFIER: UNQUOTED_IDENTIFIER | BQTEXT; +UNCLOSED_ESCAPED_IDENTIFIER: BQTEXT_0; + +// White space handling +WHITESPACE: + [ \t\f\r\n] -> channel(HIDDEN); // Ignore whitespaces. + +// Comments +fragment BLOCK_COMMENT: ('/**/' | '/*' ~[!] .*? '*/'); + +fragment DASH_COMMENT: '--' (~[\r\n])* ('\r' | '\n' | '\r\n')?; + +fragment POUND_COMMENT: '#' (~[\r\n])* ('\r' | '\n' | '\r\n')?; + +COMMENT: + (BLOCK_COMMENT | DASH_COMMENT | POUND_COMMENT) -> channel(HIDDEN); \ No newline at end of file diff --git a/googlesql/GoogleSQLParser.g4 b/googlesql/GoogleSQLParser.g4 new file mode 100644 index 0000000..157f160 --- /dev/null +++ b/googlesql/GoogleSQLParser.g4 @@ -0,0 +1,2798 @@ +parser grammar GoogleSQLParser; + +options { + tokenVocab = GoogleSQLLexer; +} + +root: stmts EOF; + +stmts: + unterminated_sql_statement ( + SEMI_SYMBOL unterminated_sql_statement + )* SEMI_SYMBOL?; + +unterminated_sql_statement: + statement_level_hint? sql_statement_body + | DEFINE_SYMBOL MACRO_SYMBOL { + p.NotifyErrorListeners("Syntax error: DEFINE MACRO statements cannot be composed from other expansions", nil, nil) + } + | statement_level_hint DEFINE_SYMBOL MACRO_SYMBOL { + p.NotifyErrorListeners("Hints are not allowed on DEFINE MACRO statements", nil, nil) + }; + +sql_statement_body: + query_statement + | alter_statement + | analyze_statement + | assert_statement + | aux_load_data_statement + | clone_data_statement + | dml_statement + | merge_statement + | truncate_statement + | begin_statement + | set_statement + | commit_statement + | start_batch_statement + | run_batch_statement + | abort_batch_statement + | create_constant_statement + | create_connection_statement + | create_database_statement + | create_function_statement + | create_procedure_statement + | create_index_statement + | create_privilege_restriction_statement + | create_row_access_policy_statement + | create_external_table_statement + | create_external_table_function_statement + | create_model_statement + | create_property_graph_statement + | create_schema_statement + | create_external_schema_statement + | create_snapshot_statement + | create_table_function_statement + | create_table_statement + | create_view_statement + | create_entity_statement + // /* TODO(zp): define macro statement */ | define_macro_statement + | define_table_statement + | describe_statement + | execute_immediate + | explain_statement + | export_data_statement + | export_model_statement + | export_metadata_statement + | gql_statement + | grant_statement + | rename_statement + | revoke_statement + | rollback_statement + | show_statement + | drop_all_row_access_policies_statement + | drop_statement + | call_statement + | import_statement + | module_statement + | undrop_statement; + +gql_statement: + GRAPH_SYMBOL path_expression graph_operation_block; + +graph_operation_block: + graph_composite_query_block ( + NEXT_SYMBOL graph_composite_query_block + )*; + +graph_composite_query_block: + graph_linear_query_operation + | graph_composite_query_prefix; + +graph_composite_query_prefix: + graph_linear_query_operation graph_set_operation_metadata graph_linear_query_operation ( + graph_set_operation_metadata graph_linear_query_operation + )*; + +graph_set_operation_metadata: + query_set_operation_type all_or_distinct; + +graph_linear_query_operation: + graph_linear_operator_list? graph_return_operator; + +graph_linear_operator_list: graph_linear_operator+; + +graph_linear_operator: + graph_match_operator + | graph_optional_match_operator + | graph_let_operator + | graph_filter_operator + | graph_order_by_operator + | graph_page_operator + | graph_with_operator + | graph_for_operator + | graph_sample_clause; + +graph_sample_clause: + TABLESAMPLE_SYMBOL identifier LR_BRACKET_SYMBOL sample_size RR_BRACKET_SYMBOL + opt_graph_sample_clause_suffix?; + +opt_graph_sample_clause_suffix: + repeatable_clause + | WITH_SYMBOL WEIGHT_SYMBOL repeatable_clause? + | WITH_SYMBOL WEIGHT_SYMBOL AS_SYMBOL identifier repeatable_clause?; + +graph_for_operator: + FOR_SYMBOL identifier IN_SYMBOL expression opt_with_offset_and_alias_with_required_as?; + +opt_with_offset_and_alias_with_required_as: + WITH_SYMBOL OFFSET_SYMBOL opt_as_alias_with_required_as?; + +graph_with_operator: + WITH_SYMBOL all_or_distinct? hint? graph_return_item_list group_by_clause?; + +graph_page_operator: graph_page_clause; + +graph_order_by_operator: graph_order_by_clause; + +graph_filter_operator: + FILTER_SYMBOL where_clause + | FILTER_SYMBOL expression; + +graph_let_operator: + LET_SYMBOL graph_let_variable_definition_list; + +graph_let_variable_definition_list: + graph_let_variable_definition ( + COMMA_SYMBOL graph_let_variable_definition + )*; + +graph_let_variable_definition: + identifier EQUAL_OPERATOR expression; + +graph_optional_match_operator: + OPTIONAL_SYMBOL MATCH_SYMBOL hint? graph_pattern; + +graph_match_operator: MATCH_SYMBOL hint? graph_pattern; + +graph_pattern: graph_path_pattern_list where_clause?; + +graph_path_pattern_list: + graph_path_pattern (COMMA_SYMBOL hint? graph_path_pattern)*; + +graph_path_pattern: + opt_path_variable_assignment? opt_graph_search_prefix? opt_graph_path_mode_prefix? + graph_path_pattern_expr; + +graph_path_pattern_expr: + graph_path_factor (hint? graph_path_factor)*; + +graph_path_factor: + graph_path_primary + | graph_quantified_path_primary; + +graph_quantified_path_primary: + graph_path_primary LC_BRACKET_SYMBOL int_literal_or_parameter? COMMA_SYMBOL + int_literal_or_parameter RC_BRACKET_SYMBOL + | graph_path_primary LC_BRACKET_SYMBOL int_literal_or_parameter RC_BRACKET_SYMBOL; + +graph_path_primary: + graph_element_pattern + | graph_parenthesized_path_pattern; + +graph_parenthesized_path_pattern: + LR_BRACKET_SYMBOL hint? graph_path_pattern where_clause? RR_BRACKET_SYMBOL; + +graph_element_pattern: graph_node_pattern | graph_edge_pattern; + +graph_edge_pattern: + LT_OPERATOR? MINUS_OPERATOR LS_BRACKET_SYMBOL graph_element_pattern_filler RS_BRACKET_SYMBOL + MINUS_OPERATOR + | MINUS_OPERATOR LS_BRACKET_SYMBOL graph_element_pattern_filler RS_BRACKET_SYMBOL + SUB_GT_BRACKET_SYMBOL + | MINUS_OPERATOR + | LT_OPERATOR MINUS_OPERATOR + | SUB_GT_BRACKET_SYMBOL; + +graph_node_pattern: + LR_BRACKET_SYMBOL graph_element_pattern_filler RR_BRACKET_SYMBOL; + +graph_element_pattern_filler: + // TODO(zp): It is better to avoid using empty production because it confused listener user. + hint? opt_graph_element_identifier? opt_is_label_expression? graph_property_specification? + | hint? opt_graph_element_identifier opt_is_label_expression? where_clause + | hint? opt_graph_element_identifier opt_is_label_expression? graph_property_specification + where_clause; + +graph_property_specification: + LC_BRACKET_SYMBOL graph_property_name_and_value ( + COMMA_SYMBOL graph_property_name_and_value + )* RC_BRACKET_SYMBOL; + +graph_property_name_and_value: + identifier COLON_SYMBOL expression; + +opt_is_label_expression: + IS_SYMBOL label_expression + | COLON_SYMBOL label_expression; + +label_expression: + label_primary + | label_expression BIT_AND_SYMBOL label_expression + | label_expression STROKE_SYMBOL label_expression + | EXCLAMATION_OPERATOR label_expression; + +label_primary: + identifier + | MODULO_OPERATOR + | parenthesized_label_expression; + +parenthesized_label_expression: + LR_BRACKET_SYMBOL label_expression RR_BRACKET_SYMBOL; + +opt_graph_element_identifier: graph_identifier; + +opt_graph_path_mode_prefix: opt_graph_path_mode path_or_paths?; + +path_or_paths: PATH_SYMBOL | PATHS_SYMBOL; + +opt_graph_path_mode: + WALK_SYMBOL + | TRAIL_SYMBOL + | SIMPLE_SYMBOL + | ACYCLIC_SYMBOL; + +opt_graph_search_prefix: + (ANY_SYMBOL | ALL_SYMBOL) SHORTEST_SYMBOL?; + +opt_path_variable_assignment: graph_identifier EQUAL_OPERATOR; + +graph_identifier: + token_identifier + | common_keyword_as_identifier; + +graph_return_operator: + RETURN_SYMBOL hint? all_or_distinct? graph_return_item_list group_by_clause? + graph_order_by_clause? graph_page_clause?; + +graph_page_clause: + OFFSET_SYMBOL possibly_cast_int_literal_or_parameter LIMIT_SYMBOL + possibly_cast_int_literal_or_parameter + | SKIP_SYMBOL possibly_cast_int_literal_or_parameter LIMIT_SYMBOL + possibly_cast_int_literal_or_parameter + | OFFSET_SYMBOL possibly_cast_int_literal_or_parameter + | SKIP_SYMBOL possibly_cast_int_literal_or_parameter + | LIMIT_SYMBOL possibly_cast_int_literal_or_parameter; + +graph_order_by_clause: + ORDER_SYMBOL hint? BY_SYMBOL graph_ordering_expression ( + COMMA_SYMBOL graph_ordering_expression + )*; + +graph_ordering_expression: + expression collate_clause? opt_graph_asc_or_desc? null_order?; + +opt_graph_asc_or_desc: + asc_or_desc + | ASCENDING_SYMBOL + | DESCENDING_SYMBOL; + +graph_return_item_list: + graph_return_item (COMMA_SYMBOL graph_return_item)*; + +graph_return_item: + expression (AS_SYMBOL identifier)? + | MULTIPLY_OPERATOR; + +undrop_statement: + UNDROP_SYMBOL schema_object_kind opt_if_not_exists? path_expression opt_at_system_time? + opt_options_list?; + +module_statement: + MODULE_SYMBOL path_expression opt_options_list?; + +import_statement: + IMPORT_SYMBOL import_type path_expression_or_string opt_as_or_into_alias? opt_options_list?; + +opt_as_or_into_alias: (AS_SYMBOL | INTO_SYMBOL) identifier; + +path_expression_or_string: path_expression | string_literal; + +import_type: MODULE_SYMBOL | PROTO_SYMBOL; + +call_statement: + CALL_SYMBOL path_expression LR_BRACKET_SYMBOL ( + tvf_argument (COMMA_SYMBOL tvf_argument)* + )? RR_BRACKET_SYMBOL; + +drop_statement: + DROP_SYMBOL PRIVILEGE_SYMBOL RESTRICTION_SYMBOL opt_if_exists? ON_SYMBOL privilege_list + ON_SYMBOL identifier path_expression + | DROP_SYMBOL ROW_SYMBOL ACCESS_SYMBOL POLICY_SYMBOL opt_if_exists? identifier + on_path_expression + | DROP_SYMBOL index_type INDEX_SYMBOL opt_if_exists? path_expression on_path_expression? + | /* TODO(zp): Refine syntax error */ DROP_SYMBOL table_or_table_function opt_if_exists? + maybe_dashed_path_expression opt_function_parameters? + | DROP_SYMBOL SNAPSHOT_SYMBOL TABLE_SYMBOL opt_if_exists? maybe_dashed_path_expression + | DROP_SYMBOL generic_entity_type opt_if_exists? path_expression + | DROP_SYMBOL schema_object_kind opt_if_exists? path_expression opt_function_parameters? + opt_drop_mode?; + +opt_drop_mode: RESTRICT_SYMBOL | CASCADE_SYMBOL; + +drop_all_row_access_policies_statement: + DROP_SYMBOL ALL_SYMBOL ROW_SYMBOL ACCESS_SYMBOL? POLICIES_SYMBOL ON_SYMBOL path_expression; + +show_statement: + SHOW_SYMBOL show_target opt_from_path_expression? opt_like_string_literal?; + +opt_like_string_literal: LIKE_SYMBOL string_literal; + +show_target: MATERIALIZED_SYMBOL VIEWS_SYMBOL | identifier; + +rename_statement: + RENAME_SYMBOL identifier path_expression TO_SYMBOL path_expression; + +revoke_statement: + REVOKE_SYMBOL privileges ON_SYMBOL (identifier identifier?)? path_expression FROM_SYMBOL + grantee_list; + +grant_statement: + GRANT_SYMBOL privileges ON_SYMBOL (identifier identifier?)? path_expression TO_SYMBOL + grantee_list; + +privileges: ALL_SYMBOL PRIVILEGES_SYMBOL? | privilege_list; + +export_metadata_statement: + EXPORT_SYMBOL table_or_table_function METADATA_SYMBOL FROM_SYMBOL maybe_dashed_path_expression + with_connection_clause? opt_options_list?; + +export_model_statement: + EXPORT_SYMBOL MODEL_SYMBOL path_expression with_connection_clause? opt_options_list?; + +export_data_statement: export_data_no_query as_query; + +export_data_no_query: + EXPORT_SYMBOL DATA_SYMBOL with_connection_clause? opt_options_list?; + +explain_statement: EXPLAIN_SYMBOL unterminated_sql_statement; + +execute_immediate: + EXECUTE_SYMBOL IMMEDIATE_SYMBOL expression opt_execute_into_clause? opt_execute_using_clause?; + +opt_execute_into_clause: INTO_SYMBOL identifier_list; + +opt_execute_using_clause: + USING_SYMBOL execute_using_argument_list; + +execute_using_argument_list: + execute_using_argument (COMMA_SYMBOL execute_using_argument)*; + +execute_using_argument: expression (AS_SYMBOL identifier)?; + +describe_statement: describe_keyword describe_info; + +describe_info: + identifier? maybe_slashed_or_dashed_path_expression opt_from_path_expression?; + +opt_from_path_expression: + FROM_SYMBOL maybe_slashed_or_dashed_path_expression; + +describe_keyword: DESCRIBE_SYMBOL | DESC_SYMBOL; + +define_table_statement: + DEFINE_SYMBOL TABLE_SYMBOL path_expression options_list?; + +create_entity_statement: + CREATE_SYMBOL opt_or_replace? generic_entity_type opt_if_not_exists? path_expression + opt_options_list? opt_generic_entity_body?; + +opt_generic_entity_body: AS_SYMBOL generic_entity_body; + +create_view_statement: + CREATE_SYMBOL opt_or_replace? opt_create_scope? RECURSIVE_SYMBOL? VIEW_SYMBOL opt_if_not_exists? + maybe_dashed_path_expression column_with_options_list? opt_sql_security_clause? + opt_options_list? as_query + | CREATE_SYMBOL opt_or_replace? MATERIALIZED_SYMBOL RECURSIVE_SYMBOL? VIEW_SYMBOL + opt_if_not_exists? maybe_dashed_path_expression column_with_options_list? + opt_sql_security_clause? partition_by_clause_prefix_no_hint? + cluster_by_clause_prefix_no_hint? opt_options_list? AS_SYMBOL query_or_replica_source + | CREATE_SYMBOL opt_or_replace? APPROX_SYMBOL RECURSIVE_SYMBOL? VIEW_SYMBOL opt_if_not_exists? + maybe_dashed_path_expression column_with_options_list? opt_sql_security_clause? + opt_options_list? as_query; + +query_or_replica_source: + query + | REPLICA_SYMBOL OF_SYMBOL maybe_dashed_path_expression; + +column_with_options_list: + LR_BRACKET_SYMBOL column_with_options ( + COMMA_SYMBOL column_with_options + )* RR_BRACKET_SYMBOL; + +column_with_options: identifier opt_options_list?; + +create_table_statement: + CREATE_SYMBOL opt_or_replace? opt_create_scope? TABLE_SYMBOL opt_if_not_exists? + maybe_dashed_path_expression table_element_list? opt_spanner_table_options? + opt_like_path_expression? opt_clone_table? opt_copy_table? opt_default_collate_clause? + partition_by_clause_prefix_no_hint? cluster_by_clause_prefix_no_hint? opt_ttl_clause? + with_connection_clause? opt_options_list? as_query?; + +opt_ttl_clause: + ROW_SYMBOL DELETION_SYMBOL POLICY_SYMBOL LR_BRACKET_SYMBOL expression RR_BRACKET_SYMBOL; + +opt_copy_table: COPY_SYMBOL copy_data_source; + +copy_data_source: + maybe_dashed_path_expression opt_at_system_time? where_clause?; + +opt_clone_table: CLONE_SYMBOL clone_data_source; + +opt_spanner_table_options: + spanner_primary_key opt_spanner_interleave_in_parent_clause?; + +opt_spanner_interleave_in_parent_clause: + COMMA_SYMBOL INTERLEAVE_SYMBOL IN_SYMBOL PARENT_SYMBOL maybe_dashed_path_expression + foreign_key_on_delete; + +spanner_primary_key: + PRIMARY_SYMBOL KEY_SYMBOL primary_key_element_list; + +create_table_function_statement: + CREATE_SYMBOL opt_or_replace? opt_create_scope? TABLE_SYMBOL FUNCTION_SYMBOL opt_if_not_exists? + path_expression opt_function_parameters? opt_returns? opt_sql_security_clause? + unordered_language_options? opt_as_query_or_string? { + if localctx.Opt_function_parameters() == nil { + p.NotifyErrorListeners("Syntax error: Expected (", nil, nil) + } + }; + +opt_as_query_or_string: as_query | AS_SYMBOL string_literal; + +unordered_language_options: + language opt_options_list? + | opt_options_list language?; + +opt_function_parameters: + LR_BRACKET_SYMBOL ( + function_parameter (COMMA_SYMBOL function_parameter)* + )? RR_BRACKET_SYMBOL; + +create_snapshot_statement: + CREATE_SYMBOL opt_or_replace? SNAPSHOT_SYMBOL ( + TABLE_SYMBOL + | schema_object_kind + ) opt_if_not_exists? maybe_dashed_path_expression CLONE_SYMBOL clone_data_source + opt_options_list?; + +create_external_schema_statement: + CREATE_SYMBOL opt_or_replace? opt_create_scope? EXTERNAL_SYMBOL SCHEMA_SYMBOL opt_if_not_exists? + path_expression with_connection_clause? opt_options_list; + +create_schema_statement: + CREATE_SYMBOL opt_or_replace? SCHEMA_SYMBOL opt_if_not_exists? path_expression + opt_default_collate_clause? opt_options_list?; + +create_property_graph_statement: + CREATE_SYMBOL opt_or_replace? PROPERTY_SYMBOL GRAPH_SYMBOL opt_if_not_exists path_expression + opt_options_list? NODE_SYMBOL TABLES_SYMBOL element_table_list opt_edge_table_clause?; + +opt_edge_table_clause: + EDGE_SYMBOL TABLES_SYMBOL element_table_list; + +element_table_list: + LR_BRACKET_SYMBOL element_table_definition ( + COMMA_SYMBOL element_table_definition + )* COMMA_SYMBOL? RR_BRACKET_SYMBOL; + +element_table_definition: + path_expression opt_as_alias_with_required_as? opt_key_clause? opt_source_node_table_clause? + opt_dest_node_table_clause? opt_label_and_properties_clause?; + +opt_label_and_properties_clause: + properties_clause + | label_and_properties_list; + +label_and_properties_list: label_and_properties+; + +label_and_properties: + DEFAULT_SYMBOL? LABEL_SYMBOL identifier properties_clause?; + +properties_clause: + NO_SYMBOL PROPERTIES_SYMBOL + | properties_all_columns opt_except_column_list? + | PROPERTIES_SYMBOL LR_BRACKET_SYMBOL derived_property_list RR_BRACKET_SYMBOL; + +derived_property_list: + derived_property (COMMA_SYMBOL derived_property)*; + +derived_property: expression opt_as_alias_with_required_as?; + +opt_except_column_list: EXCEPT_SYMBOL column_list; + +properties_all_columns: + PROPERTIES_SYMBOL ARE_SYMBOL? ALL_SYMBOL COLUMNS_SYMBOL; + +opt_dest_node_table_clause: + DESTINATION_SYMBOL KEY_SYMBOL column_list REFERENCES_SYMBOL identifier column_list?; + +opt_source_node_table_clause: + SOURCE_SYMBOL KEY_SYMBOL column_list REFERENCES_SYMBOL identifier column_list?; + +opt_key_clause: KEY_SYMBOL column_list; + +create_model_statement: + CREATE_SYMBOL opt_or_replace? opt_create_scope? MODEL_SYMBOL opt_if_not_exists? path_expression + opt_input_output_clause? opt_transform_clause? remote_with_connection_clause? + opt_options_list? opt_as_query_or_aliased_query_list?; + +opt_input_output_clause: + INPUT_SYMBOL table_element_list OUTPUT_SYMBOL table_element_list; + +opt_transform_clause: + TRANSFORM_SYMBOL LR_BRACKET_SYMBOL select_list RR_BRACKET_SYMBOL; + +opt_as_query_or_aliased_query_list: + as_query + | AS_SYMBOL LR_BRACKET_SYMBOL aliased_query_list RR_BRACKET_SYMBOL; + +aliased_query_list: aliased_query (COMMA_SYMBOL aliased_query)*; + +as_query: AS_SYMBOL query; + +create_external_table_function_statement: + CREATE_SYMBOL opt_or_replace? opt_create_scope? EXTERNAL_SYMBOL TABLE_SYMBOL FUNCTION_SYMBOL { + p.NotifyErrorListeners("Syntax error: CREATE EXTERNAL TABLE FUNCTION is not supported", nil, nil) + }; + +create_external_table_statement: + CREATE_SYMBOL opt_or_replace? opt_create_scope? EXTERNAL_SYMBOL TABLE_SYMBOL opt_if_not_exists? + maybe_dashed_path_expression table_element_list? opt_like_path_expression? + opt_default_collate_clause? opt_external_table_with_clauses? opt_options_list?; + +opt_default_collate_clause: DEFAULT_SYMBOL collate_clause; + +opt_like_path_expression: + LIKE_SYMBOL maybe_dashed_path_expression; + +create_row_access_policy_statement: + CREATE_SYMBOL opt_or_replace? ROW_SYMBOL ACCESS_SYMBOL? POLICY_SYMBOL opt_if_not_exists? + identifier? ON_SYMBOL path_expression create_row_access_policy_grant_to_clause? + filter_using_clause; + +filter_using_clause: + FILTER_SYMBOL? USING_SYMBOL LR_BRACKET_SYMBOL expression RR_BRACKET_SYMBOL; + +create_row_access_policy_grant_to_clause: + grant_to_clause + | TO_SYMBOL grantee_list; + +create_privilege_restriction_statement: + CREATE_SYMBOL opt_or_replace? PRIVILEGE_SYMBOL RESTRICTION_SYMBOL opt_if_not_exists? ON_SYMBOL + privilege_list ON_SYMBOL identifier path_expression restrict_to_clause?; + +restrict_to_clause: + RESTRICT_SYMBOL TO_SYMBOL possibly_empty_grantee_list; + +possibly_empty_grantee_list: + LR_BRACKET_SYMBOL ( + string_literal_or_parameter ( + COMMA_SYMBOL string_literal_or_parameter + )* + )? RR_BRACKET_SYMBOL; + +create_index_statement: + CREATE_SYMBOL opt_or_replace? UNIQUE_SYMBOL? opt_spanner_null_filtered? index_type? INDEX_SYMBOL + opt_if_not_exists? path_expression on_path_expression as_alias? index_unnest_expression_list + ? index_order_by_and_options index_storing_list? opt_create_index_statement_suffix?; + +opt_create_index_statement_suffix: + partition_by_clause_prefix_no_hint opt_options_list? + | opt_options_list? spanner_index_interleave_clause + | opt_options_list; + +spanner_index_interleave_clause: + COMMA_SYMBOL INTERLEAVE_SYMBOL IN_SYMBOL maybe_dashed_path_expression; + +index_storing_list: + STORING_SYMBOL index_storing_expression_list; + +index_storing_expression_list: + LR_BRACKET_SYMBOL expression (COMMA_SYMBOL expression)* RR_BRACKET_SYMBOL; + +index_order_by_and_options: + LR_BRACKET_SYMBOL column_ordering_and_options_expr ( + COMMA_SYMBOL column_ordering_and_options_expr + )* RR_BRACKET_SYMBOL + | index_all_columns; + +index_all_columns: + LR_BRACKET_SYMBOL ALL_SYMBOL COLUMNS_SYMBOL opt_with_column_options? RR_BRACKET_SYMBOL; + +opt_with_column_options: + WITH_SYMBOL COLUMN_SYMBOL OPTIONS_SYMBOL all_column_column_options; + +all_column_column_options: + LR_BRACKET_SYMBOL column_ordering_and_options_expr ( + COMMA_SYMBOL column_ordering_and_options_expr + )* RR_BRACKET_SYMBOL; + +column_ordering_and_options_expr: + expression collate_clause? asc_or_desc? null_order? opt_options_list?; + +index_unnest_expression_list: + unnest_expression_with_opt_alias_and_offset+; + +unnest_expression_with_opt_alias_and_offset: + unnest_expression as_alias? opt_with_offset_and_alias?; + +on_path_expression: ON_SYMBOL path_expression; + +index_type: SEARCH_SYMBOL | VECTOR_SYMBOL; + +opt_spanner_null_filtered: NULL_FILTERED_SYMBOL; + +create_procedure_statement: + CREATE_SYMBOL opt_or_replace? opt_create_scope? PROCEDURE_SYMBOL opt_if_not_exists? + path_expression procedure_parameters opt_external_security_clause? with_connection_clause? + opt_options_list? begin_end_block_or_language_as_code; + +begin_end_block_or_language_as_code: + begin_end_block + | LANGUAGE_SYMBOL identifier opt_as_code?; + +begin_end_block: + BEGIN_SYMBOL statement_list? opt_exception_handler? END_SYMBOL; + +opt_exception_handler: + EXCEPTION_SYMBOL WHEN_SYMBOL ERROR_SYMBOL THEN_SYMBOL statement_list; + +statement_list: + unterminated_non_empty_statement_list SEMI_SYMBOL; + +unterminated_non_empty_statement_list: + unterminated_statement (SEMI_SYMBOL unterminated_statement)*; + +unterminated_statement: + unterminated_sql_statement + | unterminated_script_statement; + +unterminated_script_statement: + if_statement + | case_statement + | variable_declaration + | break_statement + | continue_statement + | return_statement + | raise_statement + | unterminated_unlabeled_script_statement + | label COLON_SYMBOL unterminated_unlabeled_script_statement identifier?; + +label: /* TODO(zp): refine label. */ identifier; + +unterminated_unlabeled_script_statement: + begin_end_block + | while_statement + | loop_statement + | repeat_statement + | for_in_statement; + +for_in_statement: + FOR_SYMBOL identifier IN_SYMBOL parenthesized_query DO_SYMBOL statement_list? END_SYMBOL + FOR_SYMBOL; + +repeat_statement: + REPEAT_SYMBOL statement_list? until_clause END_SYMBOL REPEAT_SYMBOL; + +until_clause: UNTIL_SYMBOL expression; + +loop_statement: + LOOP_SYMBOL statement_list? END_SYMBOL LOOP_SYMBOL; + +while_statement: + WHILE_SYMBOL expression DO_SYMBOL statement_list? END_SYMBOL WHILE_SYMBOL; + +raise_statement: + RAISE_SYMBOL + | RAISE_SYMBOL USING_SYMBOL MESSAGE_SYMBOL EQUAL_OPERATOR expression; + +return_statement: RETURN_SYMBOL; + +continue_statement: + CONTINUE_SYMBOL identifier? + | ITERATE_SYMBOL identifier?; + +variable_declaration: + DECLARE_SYMBOL identifier_list type opt_default_expression? + | DECLARE_SYMBOL identifier_list DEFAULT_SYMBOL expression; + +break_statement: + BREAK_SYMBOL identifier? + | LEAVE_SYMBOL identifier?; + +case_statement: + CASE_SYMBOL expression? when_then_clauses opt_else? END_SYMBOL CASE_SYMBOL; + +when_then_clauses: + (WHEN_SYMBOL expression THEN_SYMBOL statement_list?)+; + +if_statement: + IF_SYMBOL expression THEN_SYMBOL statement_list? elseif_clauses? opt_else? END_SYMBOL IF_SYMBOL; + +elseif_clauses: + (ELSEIF_SYMBOL expression THEN_SYMBOL statement_list?)+; + +opt_else: ELSE_SYMBOL statement_list?; + +opt_as_code: AS_SYMBOL string_literal; + +opt_external_security_clause: + EXTERNAL_SYMBOL SECURITY_SYMBOL external_security_clause_kind; + +external_security_clause_kind: INVOKER_SYMBOL | DEFINER_SYMBOL; + +procedure_parameters: + LR_BRACKET_SYMBOL ( + procedure_parameter (COMMA_SYMBOL procedure_parameter)* + )? RR_BRACKET_SYMBOL; + +procedure_parameter: + opt_procedure_parameter_mode? identifier type_or_tvf_schema + | opt_procedure_parameter_mode? identifier procedure_parameter_termination { + p.NotifyErrorListeners("Syntax error: Unexpected end of parameter. Parameters should be in the format [] . If IN/OUT/INOUT is intended to be the name of a parameter, it must be escaped with backticks", nil, nil) + }; + +procedure_parameter_termination: + RR_BRACKET_SYMBOL + | COMMA_SYMBOL; + +opt_procedure_parameter_mode: + IN_SYMBOL + | OUT_SYMBOL + | INOUT_SYMBOL; + +create_function_statement: + CREATE_SYMBOL opt_or_replace? opt_create_scope? opt_aggregate? FUNCTION_SYMBOL opt_if_not_exists + ? function_declaration opt_function_returns? opt_sql_security_clause? opt_determinism_level? + opt_language_or_remote_with_connection? unordered_options_body?; + +opt_determinism_level: + DETERMINISTIC_SYMBOL + | NOT_SYMBOL DETERMINISTIC_SYMBOL + | IMMUTABLE_SYMBOL + | STABLE_SYMBOL + | VOLATILE_SYMBOL; + +opt_sql_security_clause: + SQL_SYMBOL SECURITY_SYMBOL sql_security_clause_kind; + +sql_security_clause_kind: INVOKER_SYMBOL | DEFINER_SYMBOL; + +as_sql_function_body_or_string: + AS_SYMBOL sql_function_body + | AS_SYMBOL string_literal; + +sql_function_body: + LR_BRACKET_SYMBOL expression RR_BRACKET_SYMBOL + | LR_BRACKET_SYMBOL SELECT_SYMBOL { + p.NotifyErrorListeners("The body of each CREATE FUNCTION statement is an expression, not a query; to use a query as an expression, the query must be wrapped with additional parentheses to make it a scalar subquery expression", nil, nil) + }; + +unordered_options_body: + opt_options_list as_sql_function_body_or_string? + | as_sql_function_body_or_string opt_options_list?; + +opt_language_or_remote_with_connection: + LANGUAGE_SYMBOL identifier remote_with_connection_clause? + | remote_with_connection_clause language?; + +language: LANGUAGE_SYMBOL identifier; + +remote_with_connection_clause: + REMOTE_SYMBOL with_connection_clause? + | with_connection_clause; + +with_connection_clause: WITH_SYMBOL connection_clause; + +opt_function_returns: opt_returns; + +opt_returns: RETURNS_SYMBOL type_or_tvf_schema; + +function_declaration: path_expression function_parameters; + +function_parameters: + LR_BRACKET_SYMBOL ( + function_parameter (COMMA_SYMBOL function_parameter)* + )? RR_BRACKET_SYMBOL; + +function_parameter: + identifier type_or_tvf_schema opt_as_alias_with_required_as? opt_default_expression? + opt_not_aggregate? + | type_or_tvf_schema opt_as_alias_with_required_as? opt_not_aggregate?; + +opt_not_aggregate: NOT_SYMBOL AGGREGATE_SYMBOL; + +opt_default_expression: DEFAULT_SYMBOL expression; + +type_or_tvf_schema: + type + | templated_parameter_type + | tvf_schema; + +tvf_schema: + TABLE_SYMBOL template_type_open tvf_schema_column ( + COMMA_SYMBOL tvf_schema_column + )* template_type_close; + +tvf_schema_column: identifier type | type; + +templated_parameter_type: ANY_SYMBOL templated_parameter_kind; + +templated_parameter_kind: + PROTO_SYMBOL + | ENUM_SYMBOL + | STRUCT_SYMBOL + | ARRAY_SYMBOL + | identifier; + +opt_aggregate: AGGREGATE_SYMBOL; + +create_database_statement: + CREATE_SYMBOL DATABASE_SYMBOL path_expression opt_options_list?; + +create_connection_statement: + CREATE_SYMBOL opt_or_replace? CONNECTION_SYMBOL opt_if_not_exists? path_expression + opt_options_list?; + +create_constant_statement: + CREATE_SYMBOL opt_or_replace? opt_create_scope? CONSTANT_SYMBOL opt_if_not_exists? + path_expression EQUAL_OPERATOR expression; + +opt_or_replace: OR_SYMBOL REPLACE_SYMBOL; + +opt_create_scope: + TEMP_SYMBOL + | TEMPORARY_SYMBOL + | PUBLIC_SYMBOL + | PRIVATE_SYMBOL; + +run_batch_statement: RUN_SYMBOL BATCH_SYMBOL; + +abort_batch_statement: ABORT_SYMBOL BATCH_SYMBOL; + +start_batch_statement: START_SYMBOL BATCH_SYMBOL identifier?; + +rollback_statement: ROLLBACK_SYMBOL TRANSACTION_SYMBOL?; + +commit_statement: COMMIT_SYMBOL TRANSACTION_SYMBOL?; + +set_statement: + SET_SYMBOL TRANSACTION_SYMBOL transaction_mode_list + | SET_SYMBOL identifier EQUAL_OPERATOR expression + | SET_SYMBOL named_parameter_expression EQUAL_OPERATOR expression + | SET_SYMBOL system_variable_expression EQUAL_OPERATOR expression + | SET_SYMBOL LR_BRACKET_SYMBOL identifier_list RR_BRACKET_SYMBOL EQUAL_OPERATOR expression + | SET_SYMBOL identifier COMMA_SYMBOL identifier EQUAL_OPERATOR { + p.NotifyErrorListeners("Using SET with multiple variable required parentheses around the variable list", nil, nil) + }; + +identifier_list: identifier (COMMA_SYMBOL identifier)*; + +begin_statement: + begin_transaction_keywords transaction_mode_list?; + +begin_transaction_keywords: + START_SYMBOL TRANSACTION_SYMBOL + | BEGIN_SYMBOL TRANSACTION_SYMBOL?; + +transaction_mode_list: + transaction_mode (COMMA_SYMBOL transaction_mode)*; + +transaction_mode: + READ_SYMBOL ONLY_SYMBOL + | READ_SYMBOL WRITE_SYMBOL + | ISOLATION_SYMBOL LEVEL_SYMBOL identifier + | ISOLATION_SYMBOL LEVEL_SYMBOL identifier identifier; + +truncate_statement: + TRUNCATE_SYMBOL TABLE_SYMBOL maybe_dashed_path_expression opt_where_expression?; + +merge_statement: + MERGE_SYMBOL INTO_SYMBOL? maybe_dashed_path_expression as_alias? USING_SYMBOL merge_source + ON_SYMBOL expression (merge_when_clause)+; + +merge_source: table_path_expression | table_subquery; + +merge_when_clause: + WHEN_SYMBOL MATCHED_SYMBOL opt_and_expression? THEN_SYMBOL merge_action + | WHEN_SYMBOL NOT_SYMBOL MATCHED_SYMBOL by_target? opt_and_expression? THEN_SYMBOL merge_action + | WHEN_SYMBOL NOT_SYMBOL MATCHED_SYMBOL BY_SYMBOL SOURCE_SYMBOL opt_and_expression? THEN_SYMBOL + merge_action; + +merge_action: + INSERT_SYMBOL column_list? merge_insert_value_list_or_source_row + | UPDATE_SYMBOL SET_SYMBOL update_item_list + | DELETE_SYMBOL; + +merge_insert_value_list_or_source_row: + VALUES_SYMBOL insert_values_row + | ROW_SYMBOL; + +by_target: BY_SYMBOL TARGET_SYMBOL; + +opt_and_expression: AND_SYMBOL expression; + +statement_level_hint: hint; + +// query_statement: https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax +query_statement: query; + +dml_statement: + insert_statement + | delete_statement + | update_statement; + +update_statement: + UPDATE_SYMBOL maybe_dashed_generalized_path_expression hint? as_alias? opt_with_offset_and_alias + ? SET_SYMBOL update_item_list from_clause? opt_where_expression? opt_assert_rows_modified? + opt_returning_clause?; + +delete_statement: + DELETE_SYMBOL FROM_SYMBOL? maybe_dashed_generalized_path_expression hint? as_alias? + opt_with_offset_and_alias? opt_where_expression? opt_assert_rows_modified? + opt_returning_clause?; + +insert_statement: + insert_statement_prefix column_list? insert_values_or_query opt_assert_rows_modified? + opt_returning_clause? + | insert_statement_prefix column_list? insert_values_list_or_table_clause on_conflict_clause + opt_assert_rows_modified? opt_returning_clause? + | insert_statement_prefix column_list? LR_BRACKET_SYMBOL query RR_BRACKET_SYMBOL + on_conflict_clause opt_assert_rows_modified? opt_returning_clause?; + +on_conflict_clause: + ON_SYMBOL CONFLICT_SYMBOL opt_conflict_target? DO_SYMBOL NOTHING_SYMBOL + | ON_SYMBOL CONFLICT_SYMBOL opt_conflict_target? DO_SYMBOL UPDATE_SYMBOL SET_SYMBOL + update_item_list opt_where_expression?; + +opt_where_expression: WHERE_SYMBOL expression; + +opt_conflict_target: + column_list + | ON_SYMBOL UNIQUE_SYMBOL CONSTRAINT_SYMBOL identifier; + +update_item_list: update_item (COMMA_SYMBOL update_item)*; + +update_item: update_set_value | nested_dml_statement; + +update_set_value: + generalized_path_expression EQUAL_OPERATOR expression_or_default; + +nested_dml_statement: + LR_BRACKET_SYMBOL dml_statement RR_BRACKET_SYMBOL; + +insert_values_list_or_table_clause: + insert_values_list + | table_clause_unreversed; + +table_clause_unreversed: TABLE_SYMBOL table_clause_no_keyword; + +table_clause_no_keyword: + path_expression where_clause? + | tvf_with_suffixes where_clause?; + +opt_returning_clause: + THEN_SYMBOL RETURN_SYMBOL select_list + | THEN_SYMBOL RETURN_SYMBOL WITH_SYMBOL ACTION_SYMBOL select_list + | THEN_SYMBOL RETURN_SYMBOL WITH_SYMBOL ACTION_SYMBOL AS_SYMBOL identifier select_list; + +opt_assert_rows_modified: + ASSERT_ROWS_MODIFIED_SYMBOL possibly_cast_int_literal_or_parameter; + +insert_values_or_query: insert_values_list | query; + +insert_values_list: + VALUES_SYMBOL insert_values_row ( + COMMA_SYMBOL insert_values_row + )*; + +insert_values_row: + LR_BRACKET_SYMBOL expression_or_default ( + COMMA_SYMBOL expression_or_default + )* RR_BRACKET_SYMBOL; + +expression_or_default: expression | DEFAULT_SYMBOL; + +insert_statement_prefix: + INSERT_SYMBOL opt_or_ignore_replace_update? opt_into? maybe_dashed_generalized_path_expression + hint?; + +maybe_dashed_generalized_path_expression: + generalized_path_expression + | dashed_path_expression; + +opt_into: INTO_SYMBOL; + +opt_or_ignore_replace_update: + OR_SYMBOL IGNORE_SYMBOL + | IGNORE_SYMBOL + | OR_SYMBOL REPLACE_SYMBOL + | REPLACE_SYMBOL + | OR_SYMBOL UPDATE_SYMBOL + | UPDATE_SYMBOL; + +alter_statement: + ALTER_SYMBOL table_or_table_function opt_if_exists? maybe_dashed_path_expression + alter_action_list + | ALTER_SYMBOL schema_object_kind opt_if_exists? path_expression alter_action_list + | ALTER_SYMBOL generic_entity_type opt_if_exists? path_expression alter_action_list + | ALTER_SYMBOL generic_entity_type opt_if_exists? alter_action_list + | ALTER_SYMBOL PRIVILEGE_SYMBOL RESTRICTION_SYMBOL opt_if_exists? ON_SYMBOL privilege_list + ON_SYMBOL identifier path_expression + | ALTER_SYMBOL ROW_SYMBOL ACCESS_SYMBOL POLICY_SYMBOL opt_if_exists? identifier ON_SYMBOL + path_expression row_access_policy_alter_action_list + | ALTER_SYMBOL ALL_SYMBOL ROW_SYMBOL ACCESS_SYMBOL POLICIES_SYMBOL ON_SYMBOL path_expression + row_access_policy_alter_action; + +analyze_statement: + ANALYZE_SYMBOL opt_options_list? table_and_column_info_list?; + +assert_statement: ASSERT_SYMBOL expression opt_description?; + +aux_load_data_statement: + LOAD_SYMBOL DATA_SYMBOL append_or_overwrite maybe_dashed_path_expression_with_scope + table_element_list? load_data_partitions_clause? collate_clause? + partition_by_clause_prefix_no_hint? cluster_by_clause_prefix_no_hint? opt_options_list? + aux_load_data_from_files_options_list opt_external_table_with_clauses?; + +clone_data_statement: + CLONE_SYMBOL DATA_SYMBOL INTO_SYMBOL maybe_dashed_path_expression FROM_SYMBOL + clone_data_source_list; + +clone_data_source_list: + clone_data_source (UNION_SYMBOL ALL_SYMBOL clone_data_source)*; + +clone_data_source: + maybe_dashed_path_expression opt_at_system_time? where_clause?; + +opt_external_table_with_clauses: + with_partition_columns_clause with_connection_clause + | with_partition_columns_clause + | with_connection_clause; + +with_partition_columns_clause: + WITH_SYMBOL PARTITION_SYMBOL COLUMNS_SYMBOL table_element_list?; + +aux_load_data_from_files_options_list: + FROM_SYMBOL FILES_SYMBOL options_list; + +cluster_by_clause_prefix_no_hint: + CLUSTER_SYMBOL BY_SYMBOL expression (COMMA_SYMBOL expression)*; + +load_data_partitions_clause: + OVERWRITE_SYMBOL? PARTITIONS_SYMBOL LR_BRACKET_SYMBOL expression RR_BRACKET_SYMBOL; + +maybe_dashed_path_expression_with_scope: + TEMP_SYMBOL TABLE_SYMBOL maybe_dashed_path_expression + | TEMPORARY_SYMBOL TABLE_SYMBOL maybe_dashed_path_expression + | maybe_dashed_path_expression; + +table_element_list: + LR_BRACKET_SYMBOL ( + table_element (COMMA_SYMBOL table_element)* COMMA_SYMBOL? + )? RR_BRACKET_SYMBOL; + +table_element: + table_column_definition + | table_constraint_definition; + +table_constraint_definition: + primary_key_spec + | table_constraint_spec + | identifier identifier table_constraint_spec; + +append_or_overwrite: INTO_SYMBOL | OVERWRITE_SYMBOL; + +opt_description: AS_SYMBOL string_literal; + +table_and_column_info_list: + table_and_column_info (COMMA_SYMBOL table_and_column_info)*; + +table_and_column_info: + maybe_dashed_path_expression column_list?; + +row_access_policy_alter_action_list: + row_access_policy_alter_action ( + COMMA_SYMBOL row_access_policy_alter_action + )*; + +row_access_policy_alter_action: + grant_to_clause + | FILTER_SYMBOL USING_SYMBOL LR_BRACKET_SYMBOL expression RR_BRACKET_SYMBOL + | REVOKE_SYMBOL FROM_SYMBOL LR_BRACKET_SYMBOL grantee_list RR_BRACKET_SYMBOL + | REVOKE_SYMBOL FROM_SYMBOL ALL_SYMBOL + | RENAME_SYMBOL TO_SYMBOL identifier; + +grant_to_clause: + GRANT_SYMBOL TO_SYMBOL LR_BRACKET_SYMBOL grantee_list RR_BRACKET_SYMBOL; + +grantee_list: + string_literal_or_parameter ( + COMMA_SYMBOL string_literal_or_parameter + )*; + +privilege_list: privilege (COMMA_SYMBOL privilege)*; + +privilege: privilege_name path_expression_list_with_parens?; + +path_expression_list_with_parens: + LR_BRACKET_SYMBOL path_expression_list RR_BRACKET_SYMBOL; + +privilege_name: identifier | SELECT_SYMBOL; + +generic_entity_type: generic_entity_type_unchecked; + +generic_entity_type_unchecked: IDENTIFIER | PROJECT_SYMBOL; + +schema_object_kind: + AGGREGATE_SYMBOL FUNCTION_SYMBOL + | APPROX_SYMBOL VIEW_SYMBOL + | CONNECTION_SYMBOL + | CONSTANT_SYMBOL + | DATABASE_SYMBOL + | EXTERNAL_SYMBOL table_or_table_function + | EXTERNAL_SYMBOL SCHEMA_SYMBOL + | FUNCTION_SYMBOL + | INDEX_SYMBOL + | MATERIALIZED_SYMBOL VIEW_SYMBOL + | MODEL_SYMBOL + | PROCEDURE_SYMBOL + | SCHEMA_SYMBOL + | VIEW_SYMBOL; + +alter_action_list: alter_action (COMMA_SYMBOL alter_action)*; + +alter_action: + SET_SYMBOL OPTIONS_SYMBOL options_list + | SET_SYMBOL AS_SYMBOL generic_entity_body + | ADD_SYMBOL table_constraint_spec + | ADD_SYMBOL primary_key_spec + | ADD_SYMBOL CONSTRAINT_SYMBOL opt_if_not_exists? identifier + primary_key_or_table_constraint_spec + | DROP_SYMBOL CONSTRAINT_SYMBOL opt_if_exists? identifier + | DROP_SYMBOL PRIMARY_SYMBOL KEY_SYMBOL opt_if_exists? + | ALTER_SYMBOL CONSTRAINT_SYMBOL opt_if_exists? identifier constraint_enforcement + | ALTER_SYMBOL CONSTRAINT_SYMBOL opt_if_exists? identifier SET_SYMBOL OPTIONS_SYMBOL + options_list + | ADD_SYMBOL COLUMN_SYMBOL opt_if_not_exists? table_column_definition column_position? + fill_using_expression? + | DROP_SYMBOL COLUMN_SYMBOL opt_if_exists? identifier + | RENAME_SYMBOL COLUMN_SYMBOL opt_if_exists? identifier TO_SYMBOL identifier + | ALTER_SYMBOL COLUMN_SYMBOL opt_if_exists? identifier SET_SYMBOL DATA_SYMBOL TYPE_SYMBOL + field_schema + | ALTER_SYMBOL COLUMN_SYMBOL opt_if_exists? identifier SET_SYMBOL OPTIONS_SYMBOL options_list + | ALTER_SYMBOL COLUMN_SYMBOL opt_if_exists? identifier SET_SYMBOL DEFAULT_SYMBOL expression + | ALTER_SYMBOL COLUMN_SYMBOL opt_if_exists? identifier DROP_SYMBOL DEFAULT_SYMBOL + | ALTER_SYMBOL COLUMN_SYMBOL opt_if_exists? identifier DROP_SYMBOL NOT_SYMBOL NULL_SYMBOL + | ALTER_SYMBOL COLUMN_SYMBOL opt_if_exists? identifier DROP_SYMBOL GENERATED_SYMBOL + | RENAME_SYMBOL TO_SYMBOL path_expression + | SET_SYMBOL DEFAULT_SYMBOL collate_clause + | ADD_SYMBOL ROW_SYMBOL DELETION_SYMBOL POLICY_SYMBOL opt_if_not_exists? LR_BRACKET_SYMBOL + expression RR_BRACKET_SYMBOL + | REPLACE_SYMBOL ROW_SYMBOL DELETION_SYMBOL POLICY_SYMBOL opt_if_exists? LR_BRACKET_SYMBOL + expression RR_BRACKET_SYMBOL + | DROP_SYMBOL ROW_SYMBOL DELETION_SYMBOL POLICY_SYMBOL opt_if_exists? + | ALTER_SYMBOL generic_sub_entity_type opt_if_exists? identifier alter_action + | ADD_SYMBOL generic_sub_entity_type opt_if_not_exists? identifier + | DROP_SYMBOL generic_sub_entity_type opt_if_exists? identifier + | spanner_alter_column_action + | spanner_set_on_delete_action; + +spanner_set_on_delete_action: + SET_SYMBOL ON_SYMBOL DELETE_SYMBOL foreign_key_action; + +spanner_alter_column_action: + ALTER_SYMBOL COLUMN_SYMBOL opt_if_exists? identifier column_schema_inner + not_null_column_attribute? spanner_generated_or_default? opt_options_list?; + +spanner_generated_or_default: + AS_SYMBOL LR_BRACKET_SYMBOL expression RR_BRACKET_SYMBOL STORED_SYMBOL; + +generic_sub_entity_type: sub_entity_type_identifier; + +sub_entity_type_identifier: IDENTIFIER | REPLICA_SYMBOL; + +fill_using_expression: FILL_SYMBOL USING_SYMBOL expression; + +column_position: + PRECEDING_SYMBOL identifier + | FOLLOWING_SYMBOL identifier; + +table_column_definition: + identifier table_column_schema column_attributes? opt_options_list?; + +column_attributes: column_attribute+ constraint_enforcement?; + +column_attribute: + primary_key_column_attribute + | foreign_key_column_attribute + | hidden_column_attribute + | not_null_column_attribute; + +primary_key_column_attribute: PRIMARY_SYMBOL KEY_SYMBOL; + +foreign_key_column_attribute: + opt_constraint_identity? foreign_key_reference; + +hidden_column_attribute: HIDDEN_SYMBOL; + +opt_constraint_identity: CONSTRAINT_SYMBOL identifier; + +table_column_schema: + column_schema_inner collate_clause? opt_column_info? + | generated_column_info; + +opt_column_info: + generated_column_info invalid_default_column? { + if localctx.Invalid_default_column() != nil { + p.NotifyErrorListeners("Syntax error: \"DEFAULT\" and \"GENERATED ALWAYS AS\" clauses must not be both provided for the column", nil, nil) + } + } + | default_column_info invalid_generated_column? { + if localctx.Invalid_generated_column() != nil { + p.NotifyErrorListeners("Syntax error: \"DEFAULT\" and \"GENERATED ALWAYS AS\" clauses must not be both provided for the column", nil, nil) + } + }; + +invalid_generated_column: generated_column_info; + +invalid_default_column: default_column_info; + +default_column_info: DEFAULT_SYMBOL expression; + +generated_column_info: + generated_mode LR_BRACKET_SYMBOL expression RR_BRACKET_SYMBOL stored_mode? + | generated_mode identity_column_info; + +identity_column_info: + IDENTITY_SYMBOL LR_BRACKET_SYMBOL opt_start_with? opt_increment_by? opt_maxvalue? opt_minvalue? + opt_cycle? RR_BRACKET_SYMBOL; + +opt_start_with: START_SYMBOL WITH_SYMBOL signed_numeric_literal; + +opt_increment_by: + INCREMENT_SYMBOL BY_SYMBOL signed_numeric_literal; + +opt_maxvalue: MAXVALUE_SYMBOL signed_numeric_literal; + +opt_minvalue: MINVALUE_SYMBOL signed_numeric_literal; + +opt_cycle: CYCLE_SYMBOL | NO_SYMBOL CYCLE_SYMBOL; + +signed_numeric_literal: + integer_literal + | numeric_literal + | bignumeric_literal + | floating_point_literal + | MINUS_OPERATOR integer_literal + | MINUS_OPERATOR floating_point_literal; + +// All rules reference stored_mode should make stored_mode optional. +stored_mode: STORED_SYMBOL VOLATILE_SYMBOL | STORED_SYMBOL; + +generated_mode: + GENERATED_SYMBOL AS_SYMBOL + | GENERATED_SYMBOL ALWAYS_SYMBOL AS_SYMBOL + | GENERATED_SYMBOL BY_SYMBOL DEFAULT_SYMBOL AS_SYMBOL + | AS_SYMBOL; + +column_schema_inner: + raw_column_schema_inner opt_type_parameters?; + +raw_column_schema_inner: + simple_column_schema_inner + | array_column_schema_inner + | struct_column_schema_inner + | range_column_schema_inner; + +range_column_schema_inner: + RANGE_SYMBOL template_type_open field_schema template_type_close; + +struct_column_schema_inner: + STRUCT_SYMBOL template_type_open ( + struct_column_field (COMMA_SYMBOL struct_column_field)* + )? template_type_close; + +struct_column_field: + column_schema_inner collate_clause? opt_field_attributes? + | identifier field_schema; + +simple_column_schema_inner: path_expression | INTERVAL_SYMBOL; + +array_column_schema_inner: + ARRAY_SYMBOL template_type_open field_schema template_type_close; + +field_schema: + column_schema_inner collate_clause? opt_field_attributes? opt_options_list?; + +opt_field_attributes: not_null_column_attribute; + +not_null_column_attribute: NOT_SYMBOL NULL_SYMBOL; + +primary_key_or_table_constraint_spec: + primary_key_spec + | table_constraint_spec; + +opt_if_not_exists: IF_SYMBOL NOT_SYMBOL EXISTS_SYMBOL; + +primary_key_spec: + PRIMARY_SYMBOL KEY_SYMBOL primary_key_element_list constraint_enforcement? opt_options_list?; + +primary_key_element_list: + LR_BRACKET_SYMBOL ( + primary_key_element (COMMA_SYMBOL primary_key_element)* + )? RR_BRACKET_SYMBOL; + +primary_key_element: identifier asc_or_desc? null_order?; + +table_constraint_spec: + CHECK_SYMBOL LR_BRACKET_SYMBOL expression RR_BRACKET_SYMBOL constraint_enforcement? + opt_options_list? + | FOREIGN_SYMBOL KEY_SYMBOL column_list foreign_key_reference constraint_enforcement? + opt_options_list?; + +foreign_key_reference: + REFERENCES_SYMBOL path_expression column_list opt_foreign_key_match? opt_foreign_key_action?; + +opt_foreign_key_action: + foreign_key_on_update foreign_key_on_delete? + | foreign_key_on_delete foreign_key_on_update?; + +foreign_key_on_update: + ON_SYMBOL UPDATE_SYMBOL foreign_key_action; + +foreign_key_on_delete: + ON_SYMBOL DELETE_SYMBOL foreign_key_action; + +foreign_key_action: + NO_SYMBOL ACTION_SYMBOL + | RESTRICT_SYMBOL + | CASCADE_SYMBOL + | SET_SYMBOL NULL_SYMBOL; + +opt_foreign_key_match: MATCH_SYMBOL foreign_key_match_mode; + +foreign_key_match_mode: + SIMPLE_SYMBOL + | FULL_SYMBOL + | NOT_SYMBOL DISTINCT_SYMBOL; + +column_list: + LR_BRACKET_SYMBOL identifier (COMMA_SYMBOL identifier)* RR_BRACKET_SYMBOL; + +opt_options_list: OPTIONS_SYMBOL options_list; + +constraint_enforcement: NOT_SYMBOL? ENFORCED_SYMBOL; + +generic_entity_body: json_literal | string_literal; + +opt_if_exists: IF_SYMBOL EXISTS_SYMBOL; + +table_or_table_function: TABLE_SYMBOL FUNCTION_SYMBOL?; + +query: query_without_pipe_operators; + +query_without_pipe_operators: + with_clause query_primary_or_set_operation order_by_clause? limit_offset_clause? + | with_clause_with_trailing_comma select_or_from_keyword {p.NotifyErrorListeners("Syntax error: Trailing comma after the WITH clause before the main query is not allowed", nil, nil) + } + | with_clause PIPE_SYMBOL {p.NotifyErrorListeners("Syntax error: A pipe operator cannot follow the WITH clause before the main query; The main query usually starts with SELECT or FROM here", nil, nil) + } + | query_primary_or_set_operation order_by_clause? limit_offset_clause? + | with_clause? from_clause {p.NotifyErrorListeners("Syntax error: Unexpected FROM", nil, nil)} + // FIXME(zp): Inject the keyword from original input. + | with_clause? from_clause bad_keyword_after_from_query {p.NotifyErrorListeners("Syntax error: not supported after FROM query; Consider using pipe operator `|>` ", nil, nil) + } + | with_clause? from_clause bad_keyword_after_from_query_allows_parens {p.NotifyErrorListeners("Syntax error: not supported after FROM query; Consider using pipe operator `|>` ", nil, nil) + }; + +bad_keyword_after_from_query: + WHERE_SYMBOL + | SELECT_SYMBOL + | GROUP_SYMBOL; + +bad_keyword_after_from_query_allows_parens: + ORDER_SYMBOL + | UNION_SYMBOL + | INTERSECT_SYMBOL + | EXCEPT_SYMBOL + | LIMIT_SYMBOL; + +with_clause_with_trailing_comma: with_clause COMMA_SYMBOL; + +select_or_from_keyword: SELECT_SYMBOL | FROM_SYMBOL; + +query_primary_or_set_operation: + query_primary + | query_set_operation; + +query_set_operation: query_set_operation_prefix; + +query_set_operation_prefix: + query_primary query_set_operation_item+ + | query_primary set_operation_metadata FROM_SYMBOL { p.NotifyErrorListeners("Syntax error: Unexpected FROM;FROM queries following a set operation must be parenthesized", nil, nil); + } + | query_set_operation_prefix set_operation_metadata FROM_SYMBOL { p.NotifyErrorListeners("Syntax error: Unexpected FROM;FROM queries following a set operation must be parenthesized", nil, nil); + }; + +query_set_operation_item: set_operation_metadata query_primary; + +query_primary: + select + | parenthesized_query opt_as_alias_with_required_as?; + +set_operation_metadata: + opt_corresponding_outer_mode? query_set_operation_type hint? all_or_distinct opt_strict? + opt_column_match_suffix?; + +opt_column_match_suffix: + CORRESPONDING_SYMBOL + | CORRESPONDING_SYMBOL BY_SYMBOL; + +opt_strict: STRICT_SYMBOL; + +all_or_distinct: ALL_SYMBOL | DISTINCT_SYMBOL; + +query_set_operation_type: + UNION_SYMBOL + | EXCEPT_SYMBOL + | INTERSECT_SYMBOL; + +opt_corresponding_outer_mode: + FULL_SYMBOL opt_outer? + | OUTER_SYMBOL + | LEFT_SYMBOL opt_outer?; + +opt_outer: OUTER_SYMBOL; + +with_clause: + WITH_SYMBOL RECURSIVE_SYMBOL? aliased_query ( + COMMA_SYMBOL aliased_query + )*; + +aliased_query: + identifier AS_SYMBOL parenthesized_query opt_aliased_query_modifiers?; + +opt_aliased_query_modifiers: recursion_depth_modifier; + +recursion_depth_modifier: + WITH_SYMBOL DEPTH_SYMBOL opt_as_alias_with_required_as? + | WITH_SYMBOL DEPTH_SYMBOL opt_as_alias_with_required_as? BETWEEN_SYMBOL + possibly_unbounded_int_literal_or_parameter AND_SYMBOL + possibly_unbounded_int_literal_or_parameter + | WITH_SYMBOL DEPTH_SYMBOL opt_as_alias_with_required_as? MAX_SYMBOL + possibly_unbounded_int_literal_or_parameter; + +possibly_unbounded_int_literal_or_parameter: + int_literal_or_parameter + | UNBOUNDED_SYMBOL; + +int_literal_or_parameter: + integer_literal + | parameter_expression + | system_variable_expression; + +order_by_clause: order_by_clause_prefix; + +order_by_clause_prefix: + ORDER_SYMBOL hint? BY_SYMBOL ordering_expression ( + COMMA_SYMBOL ordering_expression + )*; + +ordering_expression: + expression collate_clause? asc_or_desc? null_order?; + +select: select_clause from_clause? opt_clauses_following_from?; + +opt_clauses_following_from: + where_clause group_by_clause? having_clause? qualify_clause_nonreserved? window_clause? + | opt_clauses_following_where; + +opt_clauses_following_where: + group_by_clause having_clause? qualify_clause_nonreserved? window_clause? + | opt_clauses_following_group_by; + +opt_clauses_following_group_by: + having_clause qualify_clause_nonreserved? window_clause? + | qualify_clause_nonreserved window_clause? + | window_clause; + +window_clause: window_clause_prefix; + +window_clause_prefix: + WINDOW_SYMBOL window_definition ( + COMMA_SYMBOL window_definition + )*; + +window_definition: identifier AS_SYMBOL window_specification; + +where_clause: WHERE_SYMBOL expression; + +having_clause: HAVING_SYMBOL expression; + +group_by_clause: group_by_all | group_by_clause_prefix; + +group_by_all: group_by_preamble ALL_SYMBOL; + +select_clause: + SELECT_SYMBOL hint? opt_select_with? all_or_distinct? opt_select_as_clause? select_list + | SELECT_SYMBOL hint? opt_select_with? all_or_distinct? opt_select_as_clause? FROM_SYMBOL {p.NotifyErrorListeners("Syntax error: SELECT list must not be empty", nil, nil) + }; + +opt_select_as_clause: + AS_SYMBOL STRUCT_SYMBOL + | AS_SYMBOL path_expression; + +opt_select_with: + WITH_SYMBOL identifier + | WITH_SYMBOL identifier OPTIONS_SYMBOL options_list; + +// from_clause: https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#from_clause +from_clause: FROM_SYMBOL from_clause_contents; + +from_clause_contents: + table_primary from_clause_contents_suffix* + | AT_SYMBOL {p.NotifyErrorListeners("Query parameters cannot be used in place of table names",nil,nil) + } + | QUESTION_SYMBOL {p.NotifyErrorListeners("Query parameters cannot be used in place of table names",nil,nil) + } + | ATAT_SYMBOL {p.NotifyErrorListeners("System variables cannot be used in place of table names",nil,nil) + }; + +from_clause_contents_suffix: + COMMA_SYMBOL table_primary + | opt_natural? join_type? join_hint? JOIN_SYMBOL hint? table_primary on_or_using_clause_list?; + +table_primary: + tvf_with_suffixes + | table_path_expression + | LR_BRACKET_SYMBOL join RR_BRACKET_SYMBOL + | table_subquery + | table_primary match_recognize_clause + | table_primary sample_clause; + +tvf_with_suffixes: + tvf_prefix_no_args RR_BRACKET_SYMBOL hint? pivot_or_unpivot_clause_and_aliases? + | tvf_prefix RR_BRACKET_SYMBOL hint? pivot_or_unpivot_clause_and_aliases?; + +pivot_or_unpivot_clause_and_aliases: + AS_SYMBOL identifier + | identifier + | AS_SYMBOL identifier pivot_clause as_alias? + | AS_SYMBOL identifier unpivot_clause as_alias? + | AS_SYMBOL identifier qualify_clause_nonreserved { + p.NotifyErrorListeners("QUALIFY clause must be used in conjunction with WHERE or GROUP BY or HAVING clause", nil, nil); + } + | identifier pivot_clause as_alias + | identifier unpivot_clause as_alias + | identifier qualify_clause_nonreserved { + p.NotifyErrorListeners("QUALIFY clause must be used in conjunction with WHERE or GROUP BY or HAVING clause", nil, nil); + } + | pivot_clause as_alias? + | unpivot_clause as_alias? + | qualify_clause_nonreserved { + p.NotifyErrorListeners("QUALIFY clause must be used in conjunction with WHERE or GROUP BY or HAVING clause", nil, nil); + }; + +as_alias: AS_SYMBOL? identifier; + +sample_clause: + TABLESAMPLE_SYMBOL identifier LR_BRACKET_SYMBOL sample_size RR_BRACKET_SYMBOL + opt_sample_clause_suffix; + +opt_sample_clause_suffix: + repeatable_clause + | WITH_SYMBOL WEIGHT_SYMBOL repeatable_clause? + | WITH_SYMBOL WEIGHT_SYMBOL identifier repeatable_clause? + | WITH_SYMBOL WEIGHT_SYMBOL AS_SYMBOL identifier repeatable_clause?; + +repeatable_clause: + REPEATABLE_SYMBOL LR_BRACKET_SYMBOL possibly_cast_int_literal_or_parameter RR_BRACKET_SYMBOL; + +possibly_cast_int_literal_or_parameter: + cast_int_literal_or_parameter + | int_literal_or_parameter; + +cast_int_literal_or_parameter: + CAST_SYMBOL LR_BRACKET_SYMBOL int_literal_or_parameter AS_SYMBOL type opt_format? + RR_BRACKET_SYMBOL; + +sample_size: + sample_size_value sample_size_unit partition_by_clause_prefix_no_hint?; + +sample_size_value: + possibly_cast_int_literal_or_parameter + | floating_point_literal; + +sample_size_unit: ROWS_SYMBOL | PERCENT_SYMBOL; + +partition_by_clause_prefix_no_hint: + PARTITION_SYMBOL BY_SYMBOL expression ( + COMMA_SYMBOL expression + )*; + +match_recognize_clause: + MATCH_RECOGNIZE_SYMBOL LR_BRACKET_SYMBOL partition_by_clause_prefix? order_by_clause + MEASURES_SYMBOL select_list_prefix_with_as_aliases PATTERN_SYMBOL LR_BRACKET_SYMBOL + row_pattern_expr RR_BRACKET_SYMBOL DEFINE_SYMBOL with_expression_variable_prefix + RR_BRACKET_SYMBOL as_alias?; + +row_pattern_expr: + row_pattern_concatenation + | row_pattern_expr STROKE_SYMBOL row_pattern_concatenation; + +row_pattern_concatenation: + row_pattern_factor + | row_pattern_concatenation row_pattern_factor; + +row_pattern_factor: + identifier + | LR_BRACKET_SYMBOL row_pattern_expr RR_BRACKET_SYMBOL; + +select_list_prefix_with_as_aliases: + select_column_expr_with_as_alias ( + COMMA_SYMBOL select_column_expr_with_as_alias + )*; + +select_column_expr_with_as_alias: + expression AS_SYMBOL identifier; + +table_subquery: + parenthesized_query opt_pivot_or_unpivot_clause_and_alias?; + +join: table_primary join_item*; + +// join_item resolves the mutually left-recursive for [join, join_input]. join_input: join | +// table_primary; +join_item: + opt_natural? join_type? join_hint? JOIN_SYMBOL hint? table_primary on_or_using_clause_list?; + +on_or_using_clause_list: on_or_using_clause+; + +on_or_using_clause: on_clause | using_clause; + +using_clause: + USING_SYMBOL LR_BRACKET_SYMBOL identifier ( + DOT_SYMBOL identifier + )* RR_BRACKET_SYMBOL; + +join_hint: HASH_SYMBOL | LOOKUP_SYMBOL; + +table_path_expression: + table_path_expression_base hint? opt_pivot_or_unpivot_clause_and_alias? + opt_with_offset_and_alias? opt_at_system_time?; + +opt_at_system_time: + FOR_SYMBOL SYSTEM_SYMBOL TIME_SYMBOL AS_SYMBOL OF_SYMBOL expression + | FOR_SYMBOL SYSTEM_TIME_SYMBOL AS_SYMBOL OF_SYMBOL expression; + +opt_with_offset_and_alias: WITH_SYMBOL OFFSET_SYMBOL as_alias?; + +opt_pivot_or_unpivot_clause_and_alias: + AS_SYMBOL identifier + | identifier + | AS_SYMBOL identifier pivot_clause as_alias? + | AS_SYMBOL identifier unpivot_clause as_alias? + | AS_SYMBOL identifier qualify_clause_nonreserved {p.NotifyErrorListeners("QUALIFY clause must be used in conjunction with WHERE or GROUP BY or HAVING clause", nil, nil) + } + | identifier pivot_clause as_alias? + | identifier unpivot_clause as_alias? + | identifier qualify_clause_nonreserved {p.NotifyErrorListeners("QUALIFY clause must be used in conjunction with WHERE or GROUP BY or HAVING clause", nil, nil) + } + | pivot_clause as_alias? + | unpivot_clause as_alias? + | qualify_clause_nonreserved {p.NotifyErrorListeners("QUALIFY clause must be used in conjunction with WHERE or GROUP BY or HAVING clause", nil, nil) + }; + +table_path_expression_base: + unnest_expression + | maybe_slashed_or_dashed_path_expression + | path_expression LS_BRACKET_SYMBOL {p.NotifyErrorListeners("Syntax error: Array element access is not allowed in the FROM clause without UNNEST; Use UNNEST()",nil,nil) + } + | path_expression DOT_SYMBOL LR_BRACKET_SYMBOL {p.NotifyErrorListeners("Syntax error: Generalized field access is not allowed in the FROM clause without UNNEST; Use UNNEST()",nil,nil) + } + | unnest_expression LS_BRACKET_SYMBOL {p.NotifyErrorListeners("Syntax error: Array element access is not allowed in the FROM clause without UNNEST; Use UNNEST()",nil,nil) + } + | unnest_expression DOT_SYMBOL LR_BRACKET_SYMBOL {p.NotifyErrorListeners("Syntax error: Generalized field access is not allowed in the FROM clause without UNNEST; Use UNNEST()",nil,nil) + }; + +maybe_slashed_or_dashed_path_expression: + maybe_dashed_path_expression + | slashed_path_expression; + +maybe_dashed_path_expression: + path_expression + | dashed_path_expression; + +dashed_path_expression: + dashed_identifier + | dashed_path_expression DOT_SYMBOL identifier; + +dashed_identifier: + identifier MINUS_OPERATOR identifier + | dashed_identifier MINUS_OPERATOR dashed_identifier + | identifier MINUS_OPERATOR INTEGER_LITERAL + | dashed_identifier MINUS_OPERATOR INTEGER_LITERAL + | identifier MINUS_OPERATOR floating_point_literal identifier + | dashed_identifier MINUS_OPERATOR floating_point_literal identifier; + +slashed_identifier: + SLASH_SYMBOL identifier_or_integer + | slashed_identifier slashed_identifier_separator identifier_or_integer + | slashed_identifier slashed_identifier_separator floating_point_literal + slashed_identifier_separator identifier_or_integer; + +identifier_or_integer: + identifier + | INTEGER_LITERAL; // TODO(zp): SCRIPT_LABEL; + +slashed_identifier_separator: + MINUS_OPERATOR SLASH_SYMBOL COLON_SYMBOL; + +slashed_path_expression: + slashed_identifier + | slashed_identifier slashed_identifier_separator floating_point_literal identifier; + +unnest_expression: + unnest_expression_prefix opt_array_zip_mode? RR_BRACKET_SYMBOL + | UNNEST_SYMBOL LR_BRACKET_SYMBOL SELECT_SYMBOL {p.NotifyErrorListeners("The argument to UNNEST is an expression, not a query; to use a query as an expression, the query must be wrapped with additional parentheses to make it a scalar subquery expression", nil, nil) + }; + +unnest_expression_prefix: + UNNEST_SYMBOL LR_BRACKET_SYMBOL expression_with_opt_alias ( + COMMA_SYMBOL expression_with_opt_alias + )*; + +opt_array_zip_mode: COMMA_SYMBOL named_argument; + +expression_with_opt_alias: + expression opt_as_alias_with_required_as?; + +tvf_prefix: + tvf_prefix_no_args tvf_argument (COMMA_SYMBOL tvf_argument)*; + +tvf_argument: + expression + | descriptor_argument + | table_clause + | model_clause + | connection_clause + | named_argument + | LR_BRACKET_SYMBOL table_clause RR_BRACKET_SYMBOL {p.NotifyErrorListeners("Syntax error: Table arguments for table-valued function calls written as \"TABLE path\" must not be enclosed in parentheses. To fix this, replace (TABLE path) with TABLE path",nil,nil) + } + | LR_BRACKET_SYMBOL model_clause RR_BRACKET_SYMBOL {p.NotifyErrorListeners("Syntax error: Model arguments for table-valued function calls written as \"MODEL path\" must not be enclosed in parentheses. To fix this, replace (MODEL path) with MODEL path",nil,nil) + } + | LR_BRACKET_SYMBOL connection_clause RR_BRACKET_SYMBOL {p.NotifyErrorListeners("Syntax error: Connection arguments for table-valued function calls written as \"CONNECTION path\" must not be enclosed in parentheses. To fix this, replace (CONNECTION path) with CONNECTION path",nil,nil) + } + | LR_BRACKET_SYMBOL named_argument RR_BRACKET_SYMBOL {p.NotifyErrorListeners("Syntax error: Named arguments for table-valued function calls written as \"name => value\" must not be enclosed in parentheses. To fix this, replace (name => value) with name => value",nil,nil) + } + | SELECT_SYMBOL {p.NotifyErrorListeners("Syntax error: Each subquery argument for table-valued function calls must be enclosed in parentheses. To fix this, replace SELECT... with (SELECT...)",nil,nil) + } + | WITH_SYMBOL {p.NotifyErrorListeners("Syntax error: Each subquery argument for table-valued function calls must be enclosed in parentheses. To fix this, replace WITH... with (WITH...)",nil,nil) + }; + +connection_clause: CONNECTION_SYMBOL path_expression_or_default; + +path_expression_or_default: path_expression | DEFAULT_SYMBOL; + +descriptor_argument: + DESCRIPTOR_SYMBOL LR_BRACKET_SYMBOL descriptor_column_list RR_BRACKET_SYMBOL; + +descriptor_column_list: + descriptor_column (COMMA_SYMBOL descriptor_column)*; + +descriptor_column: identifier; + +table_clause: + TABLE_SYMBOL tvf_with_suffixes + | TABLE_SYMBOL path_expression; + +model_clause: MODEL_SYMBOL path_expression; + +qualify_clause_nonreserved: QUALIFY_SYMBOL expression; + +unpivot_clause: + UNPIVOT_SYMBOL unpivot_nulls_filter? LR_BRACKET_SYMBOL path_expression_list_with_opt_parens + FOR_SYMBOL path_expression IN_SYMBOL unpivot_in_item_list RR_BRACKET_SYMBOL; + +unpivot_in_item_list: + unpivot_in_item_list_prefix RR_BRACKET_SYMBOL; + +unpivot_in_item_list_prefix: + LR_BRACKET_SYMBOL unpivot_in_item + | unpivot_in_item_list_prefix COMMA_SYMBOL unpivot_in_item; + +unpivot_in_item: + path_expression_list_with_opt_parens opt_as_string_or_integer?; + +opt_as_string_or_integer: + AS_SYMBOL? string_literal + | AS_SYMBOL? integer_literal; + +path_expression_list_with_opt_parens: + LR_BRACKET_SYMBOL path_expression_list RR_BRACKET_SYMBOL + | path_expression_list; + +path_expression_list: + path_expression (COMMA_SYMBOL path_expression)*; + +unpivot_nulls_filter: + EXCLUDE_SYMBOL NULLS_SYMBOL + | INCLUDE_SYMBOL NULLS_SYMBOL; + +pivot_clause: + PIVOT_SYMBOL LR_BRACKET_SYMBOL pivot_expression_list FOR_SYMBOL expression_higher_prec_than_and + IN_SYMBOL LR_BRACKET_SYMBOL pivot_value_list RR_BRACKET_SYMBOL RR_BRACKET_SYMBOL; + +pivot_expression_list: + pivot_expression (COMMA_SYMBOL pivot_expression)*; + +pivot_expression: expression as_alias?; + +pivot_value_list: pivot_value (COMMA_SYMBOL pivot_value)*; + +pivot_value: expression as_alias?; + +tvf_prefix_no_args: + path_expression + | IF_SYMBOL LR_BRACKET_SYMBOL; + +join_type: + CROSS_SYMBOL + | FULL_SYMBOL opt_outer? + | INNER_SYMBOL + | LEFT_SYMBOL opt_outer? + | RIGHT_SYMBOL opt_outer?; + +opt_natural: NATURAL_SYMBOL; + +on_clause: + ON_SYMBOL expression /* Actullay, this should be bool_expression */; + +select_list: + select_list_item (COMMA_SYMBOL select_list_item)* COMMA_SYMBOL?; + +select_list_item: + select_column_expr + | select_column_dot_star + | select_column_star; + +select_column_star: MULTIPLY_OPERATOR star_modifiers?; + +select_column_expr: + expression + | select_column_expr_with_as_alias + | expression identifier; + +select_column_dot_star: + expression_higher_prec_than_and DOT_SYMBOL MULTIPLY_OPERATOR star_modifiers?; + +star_modifiers: + star_except_list + | star_except_list? star_replace_list; + +star_except_list: + EXCEPT_SYMBOL LR_BRACKET_SYMBOL identifier ( + COMMA_SYMBOL identifier + )* RR_BRACKET_SYMBOL; + +star_replace_list: + REPLACE_SYMBOL LR_BRACKET_SYMBOL star_replace_item ( + COMMA_SYMBOL star_replace_item + )* RR_BRACKET_SYMBOL; + +star_replace_item: expression AS_SYMBOL identifier; + +// expression: https://github.com/google/zetasql/blob/194cd32b5d766d60e3ca442651d792c7fe54ea74/zetasql/parser/bison_parser.y#L7712 +expression: + expression_higher_prec_than_and + | and_expression + | expression OR_SYMBOL expression; + +// expression_higher_prec_than_and: https://github.com/google/zetasql/blob/194cd32b5d766d60e3ca442651d792c7fe54ea74/zetasql/parser/bison_parser.y#L7747 +expression_higher_prec_than_and: + // unparenthesized_expression_higher_prec_than_and scope begin + null_literal + | boolean_literal + | string_literal + | bytes_literal + | integer_literal + | numeric_literal + | bignumeric_literal + | json_literal + | floating_point_literal + | date_or_time_literal + | range_literal + | parameter_expression + | system_variable_expression + | array_constructor + | new_constructor + | braced_constructor + | braced_new_constructor + | struct_braced_constructor + | case_expression + | cast_expression + | extract_expression + | with_expression + | replace_fields_expression + | function_call_expression_with_clauses + | interval_expression + | identifier + | struct_constructor + | expression_subquery_with_keyword + | expression_higher_prec_than_and LS_BRACKET_SYMBOL expression RS_BRACKET_SYMBOL + | expression_higher_prec_than_and DOT_SYMBOL LR_BRACKET_SYMBOL path_expression RR_BRACKET_SYMBOL + | expression_higher_prec_than_and DOT_SYMBOL identifier + | NOT_SYMBOL expression_higher_prec_than_and + | expression_higher_prec_than_and like_operator any_some_all hint? unnest_expression + | expression_higher_prec_than_and like_operator any_some_all hint? + parenthesized_anysomeall_list_in_rhs + | expression_higher_prec_than_and like_operator expression_higher_prec_than_and + | expression_higher_prec_than_and distinct_operator expression_higher_prec_than_and + | expression_higher_prec_than_and in_operator hint? unnest_expression { + if localctx.Hint() != nil { + p.NotifyErrorListeners("Syntax error: HINTs cannot be specified on IN clause with UNNEST", nil, nil) + } + } + | expression_higher_prec_than_and in_operator hint? parenthesized_in_rhs + | expression_higher_prec_than_and between_operator expression_higher_prec_than_and AND_SYMBOL + expression_higher_prec_than_and + | expression_higher_prec_than_and between_operator expression_higher_prec_than_and OR_SYMBOL { + p.NotifyErrorListeners("Syntax error: Expression in BETWEEN must be parenthesized", nil, nil) + } + | expression_higher_prec_than_and is_operator UNKNOWN_SYMBOL + | expression_higher_prec_than_and is_operator null_literal + | expression_higher_prec_than_and is_operator boolean_literal + | expression_higher_prec_than_and comparative_operator expression_higher_prec_than_and + | expression_higher_prec_than_and STROKE_SYMBOL expression_higher_prec_than_and + | expression_higher_prec_than_and CIRCUMFLEX_SYMBOL expression_higher_prec_than_and + | expression_higher_prec_than_and BIT_AND_SYMBOL expression_higher_prec_than_and + | expression_higher_prec_than_and BOOL_OR_SYMBOL expression_higher_prec_than_and + | expression_higher_prec_than_and shift_operator expression_higher_prec_than_and + | expression_higher_prec_than_and additive_operator expression_higher_prec_than_and + | expression_higher_prec_than_and multiplicative_operator expression_higher_prec_than_and + | unary_operator expression_higher_prec_than_and + // unparenthesized_expression_higher_prec_than_and scope end + | parenthesized_expression_not_a_query + | parenthesized_query; + +expression_maybe_parenthesized_not_a_query: + parenthesized_expression_not_a_query + // unparenthesized_expression_higher_prec_than_and scope begin + | null_literal + | boolean_literal + | string_literal + | bytes_literal + | integer_literal + | numeric_literal + | bignumeric_literal + | json_literal + | floating_point_literal + | date_or_time_literal + | range_literal + | parameter_expression + | system_variable_expression + | array_constructor + | new_constructor + | braced_constructor + | braced_new_constructor + | struct_braced_constructor + | case_expression + | cast_expression + | extract_expression + | with_expression + | replace_fields_expression + | function_call_expression_with_clauses + | interval_expression + | identifier + | struct_constructor + | expression_subquery_with_keyword + | expression_higher_prec_than_and LS_BRACKET_SYMBOL expression RS_BRACKET_SYMBOL + | expression_higher_prec_than_and DOT_SYMBOL LR_BRACKET_SYMBOL path_expression RR_BRACKET_SYMBOL + | expression_higher_prec_than_and DOT_SYMBOL identifier + | NOT_SYMBOL expression_higher_prec_than_and + | expression_higher_prec_than_and like_operator any_some_all hint? unnest_expression + | expression_higher_prec_than_and like_operator any_some_all hint? + parenthesized_anysomeall_list_in_rhs + | expression_higher_prec_than_and like_operator expression_higher_prec_than_and + | expression_higher_prec_than_and distinct_operator expression_higher_prec_than_and + | expression_higher_prec_than_and in_operator hint? unnest_expression { + if localctx.Hint() != nil { + p.NotifyErrorListeners("Syntax error: HINTs cannot be specified on IN clause with UNNEST", nil, nil) + } + } + | expression_higher_prec_than_and in_operator hint? parenthesized_in_rhs + | expression_higher_prec_than_and between_operator expression_higher_prec_than_and AND_SYMBOL + expression_higher_prec_than_and + | expression_higher_prec_than_and between_operator expression_higher_prec_than_and OR_SYMBOL { + p.NotifyErrorListeners("Syntax error: Expression in BETWEEN must be parenthesized", nil, nil) + } + | expression_higher_prec_than_and is_operator UNKNOWN_SYMBOL + | expression_higher_prec_than_and is_operator null_literal + | expression_higher_prec_than_and is_operator boolean_literal + | expression_higher_prec_than_and comparative_operator expression_higher_prec_than_and + | expression_higher_prec_than_and STROKE_SYMBOL expression_higher_prec_than_and + | expression_higher_prec_than_and CIRCUMFLEX_SYMBOL expression_higher_prec_than_and + | expression_higher_prec_than_and BIT_AND_SYMBOL expression_higher_prec_than_and + | expression_higher_prec_than_and BOOL_OR_SYMBOL expression_higher_prec_than_and + | expression_higher_prec_than_and shift_operator expression_higher_prec_than_and + | expression_higher_prec_than_and additive_operator expression_higher_prec_than_and + | expression_higher_prec_than_and multiplicative_operator expression_higher_prec_than_and + | unary_operator expression_higher_prec_than_and + // unparenthesized_expression_higher_prec_than_and scope end + | and_expression + // Previous or_expression, replace by solving mutually left-recursive. + | expression OR_SYMBOL expression; + +parenthesized_in_rhs: + parenthesized_query + | LR_BRACKET_SYMBOL expression_maybe_parenthesized_not_a_query RR_BRACKET_SYMBOL + | in_list_two_or_more_prefix RR_BRACKET_SYMBOL; + +unary_operator: + PLUS_OPERATOR + | MINUS_OPERATOR + | BITWISE_NOT_OPERATOR; + +comparative_operator: + EQUAL_OPERATOR + | NOT_EQUAL_OPERATOR + | NOT_EQUAL2_OPERATOR + | LT_OPERATOR + | LE_OPERATOR + | GT_OPERATOR + | GE_OPERATOR; + +shift_operator: KL_OPERATOR | KR_OPERATOR; + +additive_operator: PLUS_OPERATOR | MINUS_OPERATOR; + +multiplicative_operator: MULTIPLY_OPERATOR | DIVIDE_OPERATOR; + +is_operator: IS_SYMBOL NOT_SYMBOL?; + +between_operator: NOT_SYMBOL? BETWEEN_SYMBOL; + +in_operator: NOT_SYMBOL? IN_SYMBOL; + +distinct_operator: + IS_SYMBOL NOT_SYMBOL? DISTINCT_SYMBOL FROM_SYMBOL; + +parenthesized_query: LR_BRACKET_SYMBOL query RR_BRACKET_SYMBOL; + +parenthesized_expression_not_a_query: + LR_BRACKET_SYMBOL ( + expression_maybe_parenthesized_not_a_query + ) RR_BRACKET_SYMBOL; + +parenthesized_anysomeall_list_in_rhs: + parenthesized_query + | parenthesized_expression_not_a_query + | in_list_two_or_more_prefix RR_BRACKET_SYMBOL; + +and_expression: + expression_higher_prec_than_and AND_SYMBOL expression_higher_prec_than_and ( + AND_SYMBOL expression_higher_prec_than_and + )*; + +in_list_two_or_more_prefix: + LR_BRACKET_SYMBOL expression COMMA_SYMBOL expression ( + COMMA_SYMBOL expression + )*; + +any_some_all: ANY_SYMBOL | SOME_SYMBOL | ALL_SYMBOL; + +like_operator: LIKE_SYMBOL | NOT_SYMBOL LIKE_SYMBOL; + +expression_subquery_with_keyword: + ARRAY_SYMBOL parenthesized_query + | EXISTS_SYMBOL hint? parenthesized_query; + +struct_constructor: + struct_constructor_prefix_with_keyword RR_BRACKET_SYMBOL + | struct_constructor_prefix_with_keyword_no_arg RR_BRACKET_SYMBOL + | struct_constructor_prefix_without_keyword RR_BRACKET_SYMBOL; + +struct_constructor_prefix_with_keyword: + struct_constructor_prefix_with_keyword_no_arg struct_constructor_arg ( + COMMA_SYMBOL struct_constructor_arg + )*; + +struct_constructor_arg: + expression opt_as_alias_with_required_as?; + +struct_constructor_prefix_without_keyword: + LR_BRACKET_SYMBOL expression COMMA_SYMBOL expression ( + COMMA_SYMBOL expression + )*; + +struct_constructor_prefix_with_keyword_no_arg: + struct_type LR_BRACKET_SYMBOL + | STRUCT_SYMBOL LR_BRACKET_SYMBOL; + +interval_expression: + INTERVAL_SYMBOL expression identifier (TO_SYMBOL identifier)?; + +function_call_expression_with_clauses: + // NOTE: zetasql bison.y is LALR(1) parser, it checks the first rule should be path_expression + // in action code instead of use expression directly to avoid parser ambiguous. + path_expression LR_BRACKET_SYMBOL DISTINCT_SYMBOL? function_call_expression_with_clauses_suffix + | function_name_from_keyword LR_BRACKET_SYMBOL function_call_expression_with_clauses_suffix; + +function_call_expression_with_clauses_suffix: + ( + // Empty argument list. + opt_having_or_group_by_modifier? order_by_clause? limit_offset_clause? RR_BRACKET_SYMBOL + // Non empty argument list. + | ( + (function_call_argument | MULTIPLY_OPERATOR) ( + COMMA_SYMBOL function_call_argument + )* + ) opt_null_handling_modifier? opt_having_or_group_by_modifier? clamped_between_modifier? + with_report_modifier? order_by_clause? limit_offset_clause? RR_BRACKET_SYMBOL + ) hint? with_group_rows? over_clause?; + +over_clause: OVER_SYMBOL window_specification; + +window_specification: + identifier + | LR_BRACKET_SYMBOL identifier? partition_by_clause? order_by_clause? opt_window_frame_clause? + RR_BRACKET_SYMBOL; + +opt_window_frame_clause: + frame_unit BETWEEN_SYMBOL window_frame_bound AND_SYMBOL window_frame_bound + | frame_unit window_frame_bound; + +window_frame_bound: + UNBOUNDED_SYMBOL preceding_or_following + | CURRENT_SYMBOL ROW_SYMBOL + | expression preceding_or_following; + +preceding_or_following: PRECEDING_SYMBOL | FOLLOWING_SYMBOL; + +frame_unit: ROWS_SYMBOL | RANGE_SYMBOL; + +partition_by_clause: partition_by_clause_prefix; + +partition_by_clause_prefix: + PARTITION_SYMBOL hint? BY_SYMBOL expression ( + COMMA_SYMBOL expression + )*; + +with_group_rows: + WITH_SYMBOL GROUP_SYMBOL ROWS_SYMBOL /* XXX(zp): query = parenthesized_query*/; + +with_report_modifier: + WITH_SYMBOL REPORT_SYMBOL with_report_format; + +clamped_between_modifier: + CLAMPED_SYMBOL expression_higher_prec_than_and AND_SYMBOL expression; + +with_report_format: options_list; + +options_list: + options_list_prefix RR_BRACKET_SYMBOL + | LR_BRACKET_SYMBOL RR_BRACKET_SYMBOL; + +options_list_prefix: + LR_BRACKET_SYMBOL options_entry (COMMA_SYMBOL options_entry)*; + +options_entry: + identifier_in_hints options_assignment_operator expression_or_proto; + +expression_or_proto: PROTO_SYMBOL | expression; + +options_assignment_operator: + EQUAL_OPERATOR + | PLUS_EQUAL_SYMBOL + | SUB_EQUAL_SYMBOL; + +opt_null_handling_modifier: + IGNORE_SYMBOL NULLS_SYMBOL + | RESPECT_SYMBOL NULLS_SYMBOL; + +function_call_argument: + expression opt_as_alias_with_required_as? + | named_argument + | lambda_argument + | sequence_arg + | SELECT_SYMBOL { p.NotifyErrorListeners("Each function argument is an expression, not a query; to use a query as an expression, the query must be wrapped with additional parentheses to make it a scalar subquery expression", nil, nil); + }; + +sequence_arg: SEQUENCE_SYMBOL path_expression; + +named_argument: + identifier EQUAL_GT_BRACKET_SYMBOL expression + | identifier EQUAL_GT_BRACKET_SYMBOL lambda_argument; + +lambda_argument: + lambda_argument_list SUB_GT_BRACKET_SYMBOL expression; + +lambda_argument_list: + /* XXX(zp): expr kind check expression*/ expression + | LR_BRACKET_SYMBOL RR_BRACKET_SYMBOL; + +limit_offset_clause: + LIMIT_SYMBOL expression OFFSET_SYMBOL expression + | LIMIT_SYMBOL expression; + +opt_having_or_group_by_modifier: + HAVING_SYMBOL MAX_SYMBOL expression + | HAVING_SYMBOL MIN_SYMBOL expression group_by_clause_prefix; + +group_by_clause_prefix: + group_by_preamble grouping_item (COMMA_SYMBOL grouping_item)*; + +group_by_preamble: GROUP_SYMBOL hint? opt_and_order? BY_SYMBOL; + +opt_and_order: AND_SYMBOL ORDER_SYMBOL; + +hint: + /*XXX(zp): ABORT_CHECK*/ AT_SYMBOL integer_literal + | hint_with_body; +hint_with_body: hint_with_body_prefix RC_BRACKET_SYMBOL; + +hint_with_body_prefix: + AT_SYMBOL (integer_literal AT_SYMBOL)? LC_BRACKET_SYMBOL hint_entry ( + COMMA_SYMBOL hint_entry + )*; + +hint_entry: + identifier_in_hints EQUAL_OPERATOR expression + | identifier_in_hints DOT_SYMBOL identifier_in_hints EQUAL_OPERATOR expression; + +identifier_in_hints: + identifier + | extra_identifier_in_hints_name; + +extra_identifier_in_hints_name: + HASH_SYMBOL + | PROTO_SYMBOL + | PARTITION_SYMBOL; + +grouping_item: + LR_BRACKET_SYMBOL RR_BRACKET_SYMBOL + | expression opt_as_alias_with_required_as? opt_grouping_item_order? + | rollup_list RR_BRACKET_SYMBOL + | cube_list RR_BRACKET_SYMBOL + | grouping_set_list RR_BRACKET_SYMBOL; + +grouping_set_list: + GROUPING_SYMBOL SETS_SYMBOL LR_BRACKET_SYMBOL grouping_set ( + COMMA_SYMBOL grouping_set + )*; + +grouping_set: + LR_BRACKET_SYMBOL RR_BRACKET_SYMBOL + | expression + | rollup_list RR_BRACKET_SYMBOL + | cube_list RR_BRACKET_SYMBOL; + +cube_list: + CUBE_SYMBOL LR_BRACKET_SYMBOL (COMMA_SYMBOL expression)*; + +rollup_list: + ROLLUP_SYMBOL LR_BRACKET_SYMBOL expression ( + COMMA_SYMBOL expression + )*; + +opt_as_alias_with_required_as: AS_SYMBOL identifier; + +opt_grouping_item_order: opt_selection_item_order | null_order; + +opt_selection_item_order: asc_or_desc null_order?; + +asc_or_desc: ASC_SYMBOL | DESC_SYMBOL; + +null_order: + NULLS_SYMBOL FIRST_SYMBOL + | NULLS_SYMBOL LAST_SYMBOL; + +function_name_from_keyword: + IF_SYMBOL + | GROUPING_SYMBOL + | LEFT_SYMBOL + | RIGHT_SYMBOL + | COLLATE_SYMBOL + | RANGE_SYMBOL; + +replace_fields_expression: + replace_fields_prefix RR_BRACKET_SYMBOL; + +replace_fields_prefix: + REPLACE_FIELDS_SYMBOL LR_BRACKET_SYMBOL expression COMMA_SYMBOL replace_fields_arg ( + COMMA_SYMBOL replace_fields_arg + )*; + +replace_fields_arg: + expression AS_SYMBOL generalized_path_expression + | expression AS_SYMBOL generalized_extension_path; + +generalized_path_expression: + identifier + | generalized_path_expression DOT_SYMBOL generalized_extension_path + | generalized_path_expression DOT_SYMBOL identifier + | generalized_path_expression LS_BRACKET_SYMBOL expression RS_BRACKET_SYMBOL; + +generalized_extension_path: + LR_BRACKET_SYMBOL path_expression RR_BRACKET_SYMBOL + | generalized_extension_path DOT_SYMBOL LR_BRACKET_SYMBOL path_expression RR_BRACKET_SYMBOL + | generalized_extension_path DOT_SYMBOL identifier; + +with_expression: + /* XXX(zp): zetasql Yacc implement this in lookahead_transformer. */ WITH_SYMBOL + LR_BRACKET_SYMBOL with_expression_variable_prefix COMMA_SYMBOL expression RR_BRACKET_SYMBOL; + +with_expression_variable_prefix: + with_expression_variable ( + COMMA_SYMBOL with_expression_variable + )*; + +with_expression_variable: identifier AS_SYMBOL expression; + +extract_expression: + extract_expression_base RR_BRACKET_SYMBOL + | extract_expression_base AT_SYMBOL TIME_SYMBOL ZONE_SYMBOL expression RR_BRACKET_SYMBOL; + +extract_expression_base: + EXTRACT_SYMBOL LR_BRACKET_SYMBOL expression FROM_SYMBOL expression; + +opt_format: FORMAT_SYMBOL expression opt_at_time_zone?; + +opt_at_time_zone: AT_SYMBOL TIME_SYMBOL ZONE_SYMBOL expression; + +cast_expression: + CAST_SYMBOL LR_BRACKET_SYMBOL expression AS_SYMBOL type opt_format? RR_BRACKET_SYMBOL + | CAST_SYMBOL LR_BRACKET_SYMBOL CAST_SYMBOL { p.NotifyErrorListeners("The argument to CAST is an expression, not a query; to use a query as an expression, the query must be wrapped with additional parentheses to make it a scalar subquery expression", nil, nil); + } + | SAFE_CAST_SYMBOL LR_BRACKET_SYMBOL expression AS_SYMBOL type opt_format? RR_BRACKET_SYMBOL + | SAFE_CAST_SYMBOL LR_BRACKET_SYMBOL SAFE_CAST_SYMBOL { p.NotifyErrorListeners("The argument to CAST is an expression, not a query; to use a query as an expression, the query must be wrapped with additional parentheses to make it a scalar subquery expression", nil, nil); + }; + +case_expression: + case_expression_prefix END_SYMBOL + | case_expression_prefix ELSE_SYMBOL expression END_SYMBOL; + +case_expression_prefix: + case_no_value_expression_prefix + | case_value_expression_prefix; + +case_value_expression_prefix: + CASE_SYMBOL expression ( + WHEN_SYMBOL expression THEN_SYMBOL expression + )+; + +case_no_value_expression_prefix: + CASE_SYMBOL (WHEN_SYMBOL expression THEN_SYMBOL expression)+; + +struct_braced_constructor: + stype = struct_type ctor = braced_constructor + | STRUCT_SYMBOL ctor = braced_constructor; + +braced_new_constructor: NEW_SYMBOL type_name new_constructor; + +braced_constructor: + braced_constructor_start RC_BRACKET_SYMBOL + | braced_constructor_prefix RC_BRACKET_SYMBOL + // Allow trailing comma in braced constructor. | braced_constructor_prefix + COMMA_SYMBOL RC_BRACKET_SYMBOL; + +braced_constructor_start: RC_BRACKET_SYMBOL; + +braced_constructor_prefix: + braced_constructor_start braced_constructor_field + | braced_constructor_start braced_constructor_extension + | braced_constructor_prefix COMMA_SYMBOL braced_constructor_field + | braced_constructor_prefix braced_constructor_field + | braced_constructor_prefix COMMA_SYMBOL braced_constructor_extension; + +braced_constructor_field: + braced_constructor_lhs braced_constructor_field_value; + +braced_constructor_lhs: generalized_path_expression; + +braced_constructor_field_value: + COLON_SYMBOL expression + | braced_constructor; + +braced_constructor_extension: + LR_BRACKET_SYMBOL path_expression RR_BRACKET_SYMBOL; + +new_constructor: + new_constructor_prefix RR_BRACKET_SYMBOL + | new_constructor_prefix_no_arg RR_BRACKET_SYMBOL; + +new_constructor_prefix: + new_constructor_prefix_no_arg new_constructor_arg ( + COMMA_SYMBOL new_constructor_arg + )*; + +new_constructor_prefix_no_arg: + NEW_SYMBOL type_name LR_BRACKET_SYMBOL; + +new_constructor_arg: + expression + | expression AS_SYMBOL identifier + | expression AS_SYMBOL LR_BRACKET_SYMBOL path_expression RR_BRACKET_SYMBOL; + +array_constructor: + array_constructor_prefix_no_expressions RS_BRACKET_SYMBOL + | array_constructor_prefix RS_BRACKET_SYMBOL; + +array_constructor_prefix: + array_constructor_prefix_no_expressions expression ( + COMMA_SYMBOL expression + )*; + +array_constructor_prefix_no_expressions: + ARRAY_SYMBOL LS_BRACKET_SYMBOL + | LS_BRACKET_SYMBOL + | array_type LS_BRACKET_SYMBOL; + +range_literal: range_type string_literal; + +range_type: + RANGE_SYMBOL template_type_open type template_type_close; + +type: raw_type opt_type_parameters? collate_clause?; + +collate_clause: COLLATE_SYMBOL string_literal_or_parameter; + +string_literal_or_parameter: + string_literal + | parameter_expression + | system_variable_expression; + +system_variable_expression: ATAT_SYMBOL path_expression; + +parameter_expression: + named_parameter_expression + | QUESTION_SYMBOL; + +named_parameter_expression: AT_SYMBOL identifier; + +// This is opt_type_parameters in zetasql yacc, but here prefer to use ? in ANTLR. +opt_type_parameters: + type_parameters_prefix RR_BRACKET_SYMBOL + | type_parameters_prefix COMMA_SYMBOL RR_BRACKET_SYMBOL { p.NotifyErrorListeners("Syntax error: Trailing comma in type parameters list is not allowed.", nil, nil); + }; + +type_parameters_prefix: + LR_BRACKET_SYMBOL type_parameter ( + COMMA_SYMBOL type_parameter + )*; + +type_parameter: + integer_literal + | boolean_literal + | string_literal + | bytes_literal + | floating_point_literal + | MAX_SYMBOL; + +raw_type: + array_type + | struct_type + | type_name + | range_type + | function_type + | map_type; + +map_type: + MAP_SYMBOL template_type_open key_type = type COMMA_SYMBOL value_type = type template_type_close + ; + +function_type: + FUNCTION_SYMBOL template_type_open LR_BRACKET_SYMBOL RR_BRACKET_SYMBOL SUB_GT_BRACKET_SYMBOL + return_type = type template_type_close + | FUNCTION_SYMBOL template_type_open arg_type = type SUB_GT_BRACKET_SYMBOL return_type = type + template_type_close + | arg_list = function_type_prefix RR_BRACKET_SYMBOL SUB_GT_BRACKET_SYMBOL return_type = type + template_type_close; + +function_type_prefix: + FUNCTION_SYMBOL template_type_open LR_BRACKET_SYMBOL type ( + COMMA_SYMBOL type + )*; + +type_name: path_expression | INTERVAL_SYMBOL; + +path_expression: identifier (DOT_SYMBOL identifier)*; + +identifier: token_identifier | keyword_as_identifier; + +keyword_as_identifier: + common_keyword_as_identifier + | SIMPLE_SYMBOL; + +common_keyword_as_identifier: + ABORT_SYMBOL + | ACCESS_SYMBOL + | ACTION_SYMBOL + | AGGREGATE_SYMBOL + | ADD_SYMBOL + | ALTER_SYMBOL + | ALWAYS_SYMBOL + | ANALYZE_SYMBOL + | APPROX_SYMBOL + | ARE_SYMBOL + | ASSERT_SYMBOL + | BATCH_SYMBOL + | BEGIN_SYMBOL + | BIGDECIMAL_SYMBOL + | BIGNUMERIC_SYMBOL + | BREAK_SYMBOL + | CALL_SYMBOL + | CASCADE_SYMBOL + | CHECK_SYMBOL + | CLAMPED_SYMBOL + | CONFLICT_SYMBOL + | CLONE_SYMBOL + | COPY_SYMBOL + | CLUSTER_SYMBOL + | COLUMN_SYMBOL + | COLUMNS_SYMBOL + | COMMIT_SYMBOL + | CONNECTION_SYMBOL + | CONSTANT_SYMBOL + | CONSTRAINT_SYMBOL + | CONTINUE_SYMBOL + | CORRESPONDING_SYMBOL + | CYCLE_SYMBOL + | DATA_SYMBOL + | DATABASE_SYMBOL + | DATE_SYMBOL + | DATETIME_SYMBOL + | DECIMAL_SYMBOL + | DECLARE_SYMBOL + | DEFINER_SYMBOL + | DELETE_SYMBOL + | DELETION_SYMBOL + | DEPTH_SYMBOL + | DESCRIBE_SYMBOL + | DETERMINISTIC_SYMBOL + | DO_SYMBOL + | DROP_SYMBOL + | ELSEIF_SYMBOL + | ENFORCED_SYMBOL + | ERROR_SYMBOL + | EXCEPTION_SYMBOL + | EXECUTE_SYMBOL + | EXPLAIN_SYMBOL + | EXPORT_SYMBOL + | EXTEND_SYMBOL + | EXTERNAL_SYMBOL + | FILES_SYMBOL + | FILTER_SYMBOL + | FILL_SYMBOL + | FIRST_SYMBOL + | FOREIGN_SYMBOL + | FORMAT_SYMBOL + | FUNCTION_SYMBOL + | GENERATED_SYMBOL + | GRANT_SYMBOL + | GROUP_ROWS_SYMBOL + | HIDDEN_SYMBOL + | IDENTITY_SYMBOL + | IMMEDIATE_SYMBOL + | IMMUTABLE_SYMBOL + | IMPORT_SYMBOL + | INCLUDE_SYMBOL + | INCREMENT_SYMBOL + | INDEX_SYMBOL + | INOUT_SYMBOL + | INPUT_SYMBOL + | INSERT_SYMBOL + | INVOKER_SYMBOL + | ISOLATION_SYMBOL + | ITERATE_SYMBOL + | JSON_SYMBOL + | KEY_SYMBOL + | LANGUAGE_SYMBOL + | LAST_SYMBOL + | LEAVE_SYMBOL + | LEVEL_SYMBOL + | LOAD_SYMBOL + | LOOP_SYMBOL + | MACRO_SYMBOL + | MAP_SYMBOL + | MATCH_SYMBOL + | KW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL + | MATCHED_SYMBOL + | MATERIALIZED_SYMBOL + | MAX_SYMBOL + | MAXVALUE_SYMBOL + | MEASURES_SYMBOL + | MESSAGE_SYMBOL + | METADATA_SYMBOL + | MIN_SYMBOL + | MINVALUE_SYMBOL + | MODEL_SYMBOL + | MODULE_SYMBOL + | NUMERIC_SYMBOL + | OFFSET_SYMBOL + | ONLY_SYMBOL + | OPTIONS_SYMBOL + | OUT_SYMBOL + | OUTPUT_SYMBOL + | OVERWRITE_SYMBOL + | PARTITIONS_SYMBOL + | PATTERN_SYMBOL + | PERCENT_SYMBOL + | PIVOT_SYMBOL + | POLICIES_SYMBOL + | POLICY_SYMBOL + | PRIMARY_SYMBOL + | PRIVATE_SYMBOL + | PRIVILEGE_SYMBOL + | PRIVILEGES_SYMBOL + | PROCEDURE_SYMBOL + | PROJECT_SYMBOL + | PUBLIC_SYMBOL + | RAISE_SYMBOL + | READ_SYMBOL + | REFERENCES_SYMBOL + | REMOTE_SYMBOL + | REMOVE_SYMBOL + | RENAME_SYMBOL + | REPEAT_SYMBOL + | REPEATABLE_SYMBOL + | REPLACE_SYMBOL + | REPLACE_FIELDS_SYMBOL + | REPLICA_SYMBOL + | REPORT_SYMBOL + | RESTRICT_SYMBOL + | RESTRICTION_SYMBOL + | RETURNS_SYMBOL + | RETURN_SYMBOL + | REVOKE_SYMBOL + | ROLLBACK_SYMBOL + | ROW_SYMBOL + | RUN_SYMBOL + | SAFE_CAST_SYMBOL + | SCHEMA_SYMBOL + | SEARCH_SYMBOL + | SECURITY_SYMBOL + | SEQUENCE_SYMBOL + | SETS_SYMBOL + | SHOW_SYMBOL + | SNAPSHOT_SYMBOL + | SOURCE_SYMBOL + | SQL_SYMBOL + | STABLE_SYMBOL + | START_SYMBOL + | STATIC_DESCRIBE_SYMBOL + | STORED_SYMBOL + | STORING_SYMBOL + | STRICT_SYMBOL + | SYSTEM_SYMBOL + | SYSTEM_TIME_SYMBOL + | TABLE_SYMBOL + | TABLES_SYMBOL + | TARGET_SYMBOL + | TEMP_SYMBOL + | TEMPORARY_SYMBOL + | TIME_SYMBOL + | TIMESTAMP_SYMBOL + | TRANSACTION_SYMBOL + | TRANSFORM_SYMBOL + | TRUNCATE_SYMBOL + | TYPE_SYMBOL + | UNDROP_SYMBOL + | UNIQUE_SYMBOL + | UNKNOWN_SYMBOL + | UNPIVOT_SYMBOL + | UNTIL_SYMBOL + | UPDATE_SYMBOL + | VALUE_SYMBOL + | VALUES_SYMBOL + | VECTOR_SYMBOL + | VIEW_SYMBOL + | VIEWS_SYMBOL + | VOLATILE_SYMBOL + | WEIGHT_SYMBOL + | WHILE_SYMBOL + | WRITE_SYMBOL + | ZONE_SYMBOL + | DESCRIPTOR_SYMBOL + | INTERLEAVE_SYMBOL + | NULL_FILTERED_SYMBOL + | PARENT_SYMBOL + | DESTINATION_SYMBOL + | PROPERTY_SYMBOL + | GRAPH_SYMBOL + | NODE_SYMBOL + | PROPERTIES_SYMBOL + | LABEL_SYMBOL + | EDGE_SYMBOL + | NEXT_SYMBOL + | ASCENDING_SYMBOL + | DESCENDING_SYMBOL + | SKIP_SYMBOL + | PATH_SYMBOL + | PATHS_SYMBOL + | WALK_SYMBOL + | TRAIL_SYMBOL + | ACYCLIC_SYMBOL + | OPTIONAL_SYMBOL + | LET_SYMBOL; + +token_identifier: IDENTIFIER; + +struct_type: + STRUCT_SYMBOL template_type_open template_type_close + | struct_type_prefix template_type_close; + +struct_type_prefix: + STRUCT_SYMBOL template_type_open struct_field ( + COMMA_SYMBOL struct_field + )*; + +struct_field: identifier type | type; + +array_type: + ARRAY_SYMBOL template_type_open type template_type_close; + +template_type_open: LT_OPERATOR; + +template_type_close: GT_OPERATOR; + +date_or_time_literal: date_or_time_literal_kind string_literal; + +date_or_time_literal_kind: + DATE_SYMBOL + | TIME_SYMBOL + | DATETIME_SYMBOL + | TIMESTAMP_SYMBOL; + +floating_point_literal: FLOATING_POINT_LITERAL; + +json_literal: JSON_SYMBOL string_literal; + +bignumeric_literal: bignumeric_literal_prefix string_literal; + +bignumeric_literal_prefix: + BIGNUMERIC_SYMBOL + | BIGDECIMAL_SYMBOL; + +numeric_literal: numeric_literal_prefix string_literal; + +numeric_literal_prefix: NUMERIC_SYMBOL | DECIMAL_SYMBOL; + +integer_literal: INTEGER_LITERAL; + +bytes_literal: + bytes_literal_component + | bytes_literal bytes_literal_component { + literalStopIndex, componentStartIndex := localctx.Bytes_literal().GetStop().GetStop(), localctx.Bytes_literal_component().GetStart().GetStart() + if literalStopIndex + 1 == componentStartIndex { p.NotifyErrorListeners("Syntax error: concatenated bytes literals must be separated by whitespace or comments.", nil, nil) } + } + | bytes_literal string_literal_component {p.NotifyErrorListeners("Syntax error: string and bytes literals cannot be concatenated.", nil, + nil); }; + +null_literal: NULL_SYMBOL; + +boolean_literal: TRUE_SYMBOL | FALSE_SYMBOL; + +string_literal: + string_literal_component + | string_literal string_literal_component { + literalStopIndex, componentStartIndex := localctx.String_literal().GetStop().GetStop(), localctx.String_literal_component().GetStart().GetStart() + if literalStopIndex + 1 == componentStartIndex { p.NotifyErrorListeners("Syntax error: concatenated string literals must be separated by whitespace or comments.", nil, nil) } + } + | string_literal bytes_literal_component {p.NotifyErrorListeners("Syntax error: string and bytes literals cannot be concatenated.", nil, nil); + }; + +string_literal_component: STRING_LITERAL; + +bytes_literal_component: BYTES_LITERAL; \ No newline at end of file diff --git a/googlesql/Makefile b/googlesql/Makefile new file mode 100644 index 0000000..f41ada7 --- /dev/null +++ b/googlesql/Makefile @@ -0,0 +1,7 @@ +all: build test + +build: + antlr -Dlanguage=Go -package googlesql -visitor -o . GoogleSQLLexer.g4 GoogleSQLParser.g4 + +test: + go test -v -run TestGoogleSQLParser diff --git a/googlesql/README.md b/googlesql/README.md new file mode 100644 index 0000000..242770c --- /dev/null +++ b/googlesql/README.md @@ -0,0 +1,23 @@ +# google-sql-parser + +Google SQL parser based on ANTLR4. + +## Usage + +### Build + +```shell +make build +``` + +### Test + +```shell +make test +``` + +## References + +- [Query Syntax](https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax), is the reference for the query(SELECT) syntax. + +- [zetasql Yacc parser](https://github.com/google/zetasql/blob/master/zetasql/parser/bison_parser.y), is the reference for the syntax detail missing in the document like expression. diff --git a/googlesql/examples/easy.sql b/googlesql/examples/easy.sql new file mode 100644 index 0000000..16c8a28 --- /dev/null +++ b/googlesql/examples/easy.sql @@ -0,0 +1,105 @@ +-- Valid. _5abc and dataField are valid identifiers. +SELECT + _5abc.dataField +FROM + _5abc; + +-- Valid. `5abc` and dataField are valid identifiers. +SELECT + `5abc`.dataField +FROM + `5abc`; + +-- Valid. abc5 and dataField are valid identifiers. +SELECT + abc5.dataField +FROM + abc5; + +-- Valid. `GROUP` and dataField are valid identifiers. +SELECT + `GROUP`.dataField +FROM + `GROUP`; + +-- Valid. abc5 and GROUP are valid identifiers. +SELECT + abc5.ABORT +FROM + abc5; + +SELECT + * +FROM + hello; + +SELECT + * +FROM + ( + SELECT + "apple" AS fruit, + "carrot" AS vegetable + ); + +WITH groceries AS ( + SELECT + "milk" AS dairy, + "eggs" AS protein, + "bread" AS grain +) +SELECT + g.* +FROM + groceries AS g; + +WITH orders AS ( + SELECT + 5 as order_id, + "sprocket" as item_name, + 200 as quantity +) +SELECT + * REPLACE (quantity / 2 AS quantity) +FROM + orders; + +SELECT + * +FROM + UNNEST( + ARRAY < STRUCT < x INT64, + y STRING, + z STRUCT < a INT64, + b INT64 > > > [ + (1, 'foo', (10, 11)), + (3, 'bar', (20, 21))] + ); + +WITH Coordinates AS ( + SELECT + [1,2] AS position +) +SELECT + results +FROM + Coordinates, + UNNEST(Coordinates.position) AS results; + +select + 1; + +SELECT + * +FROM + ( + SELECT + "apple" AS fruit, + "carrot" AS vegetable + ); + +select + -123; + +-- String literal +SELECT r'@(.+)'; \ No newline at end of file diff --git a/googlesql/examples/zetasql/examples/tpch/1.sql b/googlesql/examples/zetasql/examples/tpch/1.sql new file mode 100644 index 0000000..5e32bad --- /dev/null +++ b/googlesql/examples/zetasql/examples/tpch/1.sql @@ -0,0 +1,36 @@ +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +SELECT + l_returnflag, + l_linestatus, + sum(l_quantity) AS sum_qty, + sum(l_extendedprice) AS sum_base_price, + sum(l_extendedprice * (1 - l_discount)) AS sum_disc_price, + sum(l_extendedprice * (1 - l_discount) * (1 + l_tax)) AS sum_charge, + avg(l_quantity) AS avg_qty, + avg(l_extendedprice) AS avg_price, + avg(l_discount) AS avg_disc, + COUNT(*) AS count_order +FROM + lineitem +WHERE + l_shipdate <= date_sub(date '1998-12-01', INTERVAL 74 day) +GROUP BY + l_returnflag, + l_linestatus +ORDER BY + l_returnflag, + l_linestatus; \ No newline at end of file diff --git a/googlesql/examples/zetasql/examples/tpch/10.sql b/googlesql/examples/zetasql/examples/tpch/10.sql new file mode 100644 index 0000000..053247a --- /dev/null +++ b/googlesql/examples/zetasql/examples/tpch/10.sql @@ -0,0 +1,48 @@ +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +SELECT + c_custkey, + c_name, + sum(l_extendedprice * (1 - l_discount)) AS revenue, + c_acctbal, + n_name, + c_address, + c_phone, + c_comment +FROM + customer, + orders, + lineitem, + nation +WHERE + c_custkey = o_custkey + AND l_orderkey = o_orderkey + AND o_orderdate >= date '1994-02-01' + AND o_orderdate < date_add(date '1994-02-01', INTERVAL 3 month) + AND l_returnflag = 'R' + AND c_nationkey = n_nationkey +GROUP BY + c_custkey, + c_name, + c_acctbal, + c_phone, + n_name, + c_address, + c_comment +ORDER BY + revenue DESC +LIMIT 20; diff --git a/googlesql/examples/zetasql/examples/tpch/11.sql b/googlesql/examples/zetasql/examples/tpch/11.sql new file mode 100644 index 0000000..edbf595 --- /dev/null +++ b/googlesql/examples/zetasql/examples/tpch/11.sql @@ -0,0 +1,42 @@ +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +SELECT + ps_partkey, + sum(ps_supplycost * ps_availqty) AS value +FROM + partsupp, + supplier, + nation +WHERE + ps_suppkey = s_suppkey + AND s_nationkey = n_nationkey + AND n_name = 'PERU' +GROUP BY ps_partkey +HAVING + sum(ps_supplycost * ps_availqty) + > ( + SELECT sum(ps_supplycost * ps_availqty) * 0.0001000000 + FROM + partsupp, + supplier, + nation + WHERE + ps_suppkey = s_suppkey + AND s_nationkey = n_nationkey + AND n_name = 'PERU' + ) +ORDER BY value DESC; diff --git a/googlesql/examples/zetasql/examples/tpch/12.sql b/googlesql/examples/zetasql/examples/tpch/12.sql new file mode 100644 index 0000000..0a8dd5a --- /dev/null +++ b/googlesql/examples/zetasql/examples/tpch/12.sql @@ -0,0 +1,48 @@ +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +SELECT + l_shipmode, + sum( + CASE + WHEN + o_orderpriority = '1-URGENT' + OR o_orderpriority = '2-HIGH' + THEN 1 + ELSE 0 + END) AS high_line_count, + sum( + CASE + WHEN + o_orderpriority <> '1-URGENT' + AND o_orderpriority <> '2-HIGH' + THEN 1 + ELSE 0 + END) AS low_line_count +FROM + orders, + lineitem +WHERE + o_orderkey = l_orderkey + AND l_shipmode IN ('MAIL', 'AIR') + AND l_commitdate < l_receiptdate + AND l_shipdate < l_commitdate + AND l_receiptdate >= date '1997-01-01' + AND l_receiptdate < date_add(date '1997-01-01', INTERVAL 1 year) +GROUP BY + l_shipmode +ORDER BY + l_shipmode; diff --git a/googlesql/examples/zetasql/examples/tpch/13.sql b/googlesql/examples/zetasql/examples/tpch/13.sql new file mode 100644 index 0000000..619937c --- /dev/null +++ b/googlesql/examples/zetasql/examples/tpch/13.sql @@ -0,0 +1,38 @@ +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +SELECT + c_count, + COUNT(*) AS custdist +FROM + ( + SELECT + c_custkey, + COUNT(o_orderkey) c_count + FROM + customer + LEFT OUTER JOIN orders + ON + c_custkey = o_custkey + AND o_comment NOT LIKE '%unusual%packages%' + GROUP BY + c_custkey + ) AS c_orders +GROUP BY + c_count +ORDER BY + custdist DESC, + c_count DESC; diff --git a/googlesql/examples/zetasql/examples/tpch/14.sql b/googlesql/examples/zetasql/examples/tpch/14.sql new file mode 100644 index 0000000..fe7d8ab --- /dev/null +++ b/googlesql/examples/zetasql/examples/tpch/14.sql @@ -0,0 +1,32 @@ +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +SELECT + 100.00 + * sum( + CASE + WHEN p_type LIKE 'PROMO%' + THEN l_extendedprice * (1 - l_discount) + ELSE 0 + END) + / sum(l_extendedprice * (1 - l_discount)) AS promo_revenue +FROM + lineitem, + part +WHERE + l_partkey = p_partkey + AND l_shipdate >= date '1994-03-01' + AND l_shipdate < date_add(date '1994-03-01', INTERVAL 1 month); diff --git a/googlesql/examples/zetasql/examples/tpch/15.sql b/googlesql/examples/zetasql/examples/tpch/15.sql new file mode 100644 index 0000000..15b6e60 --- /dev/null +++ b/googlesql/examples/zetasql/examples/tpch/15.sql @@ -0,0 +1,43 @@ +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +WITH + revenue AS ( + SELECT + l_suppkey AS supplier_no, + sum(l_extendedprice * (1 - l_discount)) AS total_revenue + FROM lineitem + WHERE + l_shipdate >= date '1997-05-01' + AND l_shipdate < date_add(date '1997-05-01', INTERVAL 3 month) + GROUP BY l_suppkey + ) +SELECT + s_suppkey, + s_name, + s_address, + s_phone, + total_revenue +FROM + supplier, + revenue +WHERE + s_suppkey = supplier_no + AND total_revenue = ( + SELECT max(total_revenue) + FROM revenue + ) +ORDER BY s_suppkey; diff --git a/googlesql/examples/zetasql/examples/tpch/16.sql b/googlesql/examples/zetasql/examples/tpch/16.sql new file mode 100644 index 0000000..d2744d3 --- /dev/null +++ b/googlesql/examples/zetasql/examples/tpch/16.sql @@ -0,0 +1,43 @@ +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +SELECT + p_brand, + p_type, + p_size, + COUNT(DISTINCT ps_suppkey) AS supplier_cnt +FROM + partsupp, + part +WHERE + p_partkey = ps_partkey + AND p_brand <> 'Brand#13' + AND p_type NOT LIKE 'LARGE BURNISHED%' + AND p_size IN (39, 47, 37, 5, 20, 11, 25, 27) + AND ps_suppkey NOT IN ( + SELECT s_suppkey + FROM supplier + WHERE s_comment LIKE '%Customer%Complaints%' + ) +GROUP BY + p_brand, + p_type, + p_size +ORDER BY + supplier_cnt DESC, + p_brand, + p_type, + p_size; diff --git a/googlesql/examples/zetasql/examples/tpch/17.sql b/googlesql/examples/zetasql/examples/tpch/17.sql new file mode 100644 index 0000000..3ebb309 --- /dev/null +++ b/googlesql/examples/zetasql/examples/tpch/17.sql @@ -0,0 +1,33 @@ +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +SELECT + sum(l_extendedprice) / 7.0 AS avg_yearly +FROM + lineitem, + part +WHERE + p_partkey = l_partkey + AND p_brand = 'Brand#33' + AND p_container = 'LG DRUM' + AND l_quantity < ( + SELECT + 0.2 * avg(l_quantity) + FROM + lineitem + WHERE + l_partkey = p_partkey + ); diff --git a/googlesql/examples/zetasql/examples/tpch/18.sql b/googlesql/examples/zetasql/examples/tpch/18.sql new file mode 100644 index 0000000..21ad5dd --- /dev/null +++ b/googlesql/examples/zetasql/examples/tpch/18.sql @@ -0,0 +1,49 @@ +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +SELECT + c_name, + c_custkey, + o_orderkey, + o_orderdate, + o_totalprice, + sum(l_quantity) +FROM + customer, + orders, + lineitem, + # Moved IN subquery to a table subquery and a join, since there's no + # optimizer to do it automatically. + ( + SELECT l_orderkey AS selected_l_orderkey + FROM lineitem + GROUP BY l_orderkey + HAVING sum(l_quantity) > 230 + ) +WHERE + o_orderkey = selected_l_orderkey + AND c_custkey = o_custkey + AND o_orderkey = l_orderkey +GROUP BY + c_name, + c_custkey, + o_orderkey, + o_orderdate, + o_totalprice +ORDER BY + o_totalprice DESC, + o_orderdate +LIMIT 100; diff --git a/googlesql/examples/zetasql/examples/tpch/19.sql b/googlesql/examples/zetasql/examples/tpch/19.sql new file mode 100644 index 0000000..4e5c7bb --- /dev/null +++ b/googlesql/examples/zetasql/examples/tpch/19.sql @@ -0,0 +1,52 @@ +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +SELECT + sum(l_extendedprice * (1 - l_discount)) AS revenue +FROM + lineitem, + part +WHERE + # Added this because optimizer is needed to pull this out of the OR. + p_partkey = l_partkey + AND ( + ( + p_partkey = l_partkey + AND p_brand = 'Brand#53' + # and p_container in ('SM CASE', 'SM BOX', 'SM PACK', 'SM PKG') + AND l_quantity >= 5 + AND l_quantity <= 5 + 10 + AND p_size BETWEEN 1 AND 5 + # and l_shipmode in ('AIR', 'AIR REG') + AND l_shipinstruct = 'DELIVER IN PERSON') + OR ( + p_partkey = l_partkey + AND p_brand = 'Brand#41' + # and p_container in ('MED BAG', 'MED BOX', 'MED PKG', 'MED PACK') + AND l_quantity >= 15 + AND l_quantity <= 15 + 10 + AND p_size BETWEEN 1 AND 10 + # and l_shipmode in ('AIR', 'AIR REG') + AND l_shipinstruct = 'DELIVER IN PERSON') + OR ( + p_partkey = l_partkey + AND p_brand = 'Brand#21' + # and p_container in ('LG CASE', 'LG BOX', 'LG PACK', 'LG PKG') + AND l_quantity >= 29 + AND l_quantity <= 29 + 10 + AND p_size BETWEEN 1 AND 15 + # and l_shipmode in ('AIR', 'AIR REG') + AND l_shipinstruct = 'DELIVER IN PERSON')); diff --git a/googlesql/examples/zetasql/examples/tpch/2.sql b/googlesql/examples/zetasql/examples/tpch/2.sql new file mode 100644 index 0000000..1ea2830 --- /dev/null +++ b/googlesql/examples/zetasql/examples/tpch/2.sql @@ -0,0 +1,60 @@ +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +SELECT + s_acctbal, + s_name, + n_name, + p_partkey, + p_mfgr, + s_address, + s_phone, + s_comment +FROM + part, + supplier, + partsupp, + nation, + region +WHERE + p_partkey = ps_partkey + AND s_suppkey = ps_suppkey + AND p_size = 19 + AND p_type LIKE '%COPPER' + AND s_nationkey = n_nationkey + AND n_regionkey = r_regionkey + AND r_name = 'MIDDLE EAST' + AND ps_supplycost = ( + SELECT + min(ps_supplycost) + FROM + partsupp, + supplier, + nation, + region + WHERE + p_partkey = ps_partkey + AND s_suppkey = ps_suppkey + AND s_nationkey = n_nationkey + AND n_regionkey = r_regionkey + AND r_name = 'MIDDLE EAST' + ) +ORDER BY + s_acctbal DESC, + n_name, + s_name, + p_partkey +LIMIT 100; diff --git a/googlesql/examples/zetasql/examples/tpch/20.sql b/googlesql/examples/zetasql/examples/tpch/20.sql new file mode 100644 index 0000000..03c2619 --- /dev/null +++ b/googlesql/examples/zetasql/examples/tpch/20.sql @@ -0,0 +1,48 @@ +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +SELECT + s_name, + s_address +FROM + supplier, + nation +WHERE + s_suppkey IN ( + SELECT ps_suppkey + FROM + partsupp, + ( + SELECT p_partkey + FROM part + WHERE p_name LIKE 'tan%' + ) AS selected_parts + WHERE + ps_partkey = p_partkey + AND ps_availqty > ( + SELECT 0.5 * sum(l_quantity) + FROM lineitem + WHERE + l_partkey = ps_partkey + AND l_suppkey = ps_suppkey + AND l_shipdate >= date '1996-01-01' + AND l_shipdate < date_add(date '1996-01-01', INTERVAL 1 year) + ) + ) + AND s_nationkey = n_nationkey + AND n_name = 'PERU' +ORDER BY + s_name; diff --git a/googlesql/examples/zetasql/examples/tpch/21.sql b/googlesql/examples/zetasql/examples/tpch/21.sql new file mode 100644 index 0000000..07090f2 --- /dev/null +++ b/googlesql/examples/zetasql/examples/tpch/21.sql @@ -0,0 +1,52 @@ +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +SELECT + s_name, + COUNT(*) AS numwait +FROM + supplier, + lineitem l1, + orders, + nation +WHERE + s_suppkey = l1.l_suppkey + AND o_orderkey = l1.l_orderkey + AND o_orderstatus = 'F' + AND l1.l_receiptdate > l1.l_commitdate + AND EXISTS( + SELECT * + FROM lineitem l2 + WHERE + l2.l_orderkey = l1.l_orderkey + AND l2.l_suppkey <> l1.l_suppkey + ) + AND NOT EXISTS( + SELECT * + FROM lineitem l3 + WHERE + l3.l_orderkey = l1.l_orderkey + AND l3.l_suppkey <> l1.l_suppkey + AND l3.l_receiptdate > l3.l_commitdate + ) + AND s_nationkey = n_nationkey + AND n_name = 'PERU' +GROUP BY + s_name +ORDER BY + numwait DESC, + s_name +LIMIT 100; diff --git a/googlesql/examples/zetasql/examples/tpch/22.sql b/googlesql/examples/zetasql/examples/tpch/22.sql new file mode 100644 index 0000000..e18d02d --- /dev/null +++ b/googlesql/examples/zetasql/examples/tpch/22.sql @@ -0,0 +1,43 @@ +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +SELECT + cntrycode, + COUNT(*) AS numcust, + sum(c_acctbal) AS totacctbal +FROM + ( + SELECT + substr(c_phone, 1, 2) AS cntrycode, + c_acctbal + FROM customer + WHERE + substr(c_phone, 1, 2) IN ('10', '19', '14', '22', '23', '31', '13') + AND c_acctbal > ( + SELECT avg(c_acctbal) + FROM customer + WHERE + c_acctbal > 0.00 + AND substr(c_phone, 1, 2) IN ('10', '19', '14', '22', '23', '31', '13') + ) + AND NOT EXISTS( + SELECT * + FROM orders + WHERE o_custkey = c_custkey + ) + ) AS custsale +GROUP BY cntrycode +ORDER BY cntrycode; diff --git a/googlesql/examples/zetasql/examples/tpch/3.sql b/googlesql/examples/zetasql/examples/tpch/3.sql new file mode 100644 index 0000000..74fa613 --- /dev/null +++ b/googlesql/examples/zetasql/examples/tpch/3.sql @@ -0,0 +1,39 @@ +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +SELECT + l_orderkey, + sum(l_extendedprice * (1 - l_discount)) AS revenue, + o_orderdate, + o_shippriority +FROM + customer, + orders, + lineitem +WHERE + c_mktsegment = 'FURNITURE' + AND c_custkey = o_custkey + AND l_orderkey = o_orderkey + AND o_orderdate < date '1995-03-29' + AND l_shipdate > date '1995-03-29' +GROUP BY + l_orderkey, + o_orderdate, + o_shippriority +ORDER BY + revenue DESC, + o_orderdate +LIMIT 10; diff --git a/googlesql/examples/zetasql/examples/tpch/4.sql b/googlesql/examples/zetasql/examples/tpch/4.sql new file mode 100644 index 0000000..71cf927 --- /dev/null +++ b/googlesql/examples/zetasql/examples/tpch/4.sql @@ -0,0 +1,37 @@ +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +SELECT + o_orderpriority, + COUNT(*) AS order_count +FROM + orders +WHERE + o_orderdate >= date '1997-06-01' + AND o_orderdate < date_add(date '1997-06-01', INTERVAL 3 month) + AND EXISTS( + SELECT + * + FROM + lineitem + WHERE + l_orderkey = o_orderkey + AND l_commitdate < l_receiptdate + ) +GROUP BY + o_orderpriority +ORDER BY + o_orderpriority; diff --git a/googlesql/examples/zetasql/examples/tpch/5.sql b/googlesql/examples/zetasql/examples/tpch/5.sql new file mode 100644 index 0000000..4ac9fd5 --- /dev/null +++ b/googlesql/examples/zetasql/examples/tpch/5.sql @@ -0,0 +1,40 @@ +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +SELECT + n_name, + sum(l_extendedprice * (1 - l_discount)) AS revenue +FROM + customer, + orders, + lineitem, + supplier, + nation, + region +WHERE + c_custkey = o_custkey + AND l_orderkey = o_orderkey + AND l_suppkey = s_suppkey + AND c_nationkey = s_nationkey + AND s_nationkey = n_nationkey + AND n_regionkey = r_regionkey + AND r_name = 'AFRICA' + AND o_orderdate >= date '1994-01-01' + AND o_orderdate < date_add(date '1994-01-01', INTERVAL 1 year) +GROUP BY + n_name +ORDER BY + revenue DESC; diff --git a/googlesql/examples/zetasql/examples/tpch/6.sql b/googlesql/examples/zetasql/examples/tpch/6.sql new file mode 100644 index 0000000..42e91cd --- /dev/null +++ b/googlesql/examples/zetasql/examples/tpch/6.sql @@ -0,0 +1,25 @@ +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +SELECT + sum(l_extendedprice * l_discount) AS revenue +FROM + lineitem +WHERE + l_shipdate >= date '1994-01-01' + AND l_shipdate < date_add(date '1994-01-01', INTERVAL 1 year) + AND l_discount BETWEEN 0.08 - 0.01 AND 0.08 + 0.01 + AND l_quantity < 25; diff --git a/googlesql/examples/zetasql/examples/tpch/7.sql b/googlesql/examples/zetasql/examples/tpch/7.sql new file mode 100644 index 0000000..edad63f --- /dev/null +++ b/googlesql/examples/zetasql/examples/tpch/7.sql @@ -0,0 +1,54 @@ +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +SELECT + supp_nation, + cust_nation, + l_year, + sum(volume) AS revenue +FROM + ( + SELECT + n1.n_name AS supp_nation, + n2.n_name AS cust_nation, + EXTRACT(year FROM l_shipdate) AS l_year, + l_extendedprice * (1 - l_discount) AS volume + FROM + supplier, + lineitem, + orders, + customer, + nation n1, + nation n2 + WHERE + s_suppkey = l_suppkey + AND o_orderkey = l_orderkey + AND c_custkey = o_custkey + AND s_nationkey = n1.n_nationkey + AND c_nationkey = n2.n_nationkey + AND ( + (n1.n_name = 'SAUDI ARABIA' AND n2.n_name = 'UNITED KINGDOM') + OR (n1.n_name = 'UNITED KINGDOM' AND n2.n_name = 'SAUDI ARABIA')) + AND l_shipdate BETWEEN date '1995-01-01' AND date '1996-12-31' + ) AS shipping +GROUP BY + supp_nation, + cust_nation, + l_year +ORDER BY + supp_nation, + cust_nation, + l_year; diff --git a/googlesql/examples/zetasql/examples/tpch/8.sql b/googlesql/examples/zetasql/examples/tpch/8.sql new file mode 100644 index 0000000..ddfe810 --- /dev/null +++ b/googlesql/examples/zetasql/examples/tpch/8.sql @@ -0,0 +1,50 @@ +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +SELECT + o_year, + sum(CASE WHEN nation = 'PERU' THEN volume ELSE 0 END) / sum(volume) AS mkt_share +FROM + ( + SELECT + EXTRACT(year FROM o_orderdate) AS o_year, + l_extendedprice * (1 - l_discount) AS volume, + n2.n_name AS nation + FROM + part, + supplier, + lineitem, + orders, + customer, + nation n1, + nation n2, + region + WHERE + p_partkey = l_partkey + AND s_suppkey = l_suppkey + AND l_orderkey = o_orderkey + AND o_custkey = c_custkey + AND c_nationkey = n1.n_nationkey + AND n1.n_regionkey = r_regionkey + AND r_name = 'AMERICA' + AND s_nationkey = n2.n_nationkey + AND o_orderdate BETWEEN date '1993-01-01' AND date '1997-12-31' + AND p_type = 'STANDARD POLISHED TIN' + ) AS all_nations +GROUP BY + o_year +ORDER BY + o_year; diff --git a/googlesql/examples/zetasql/examples/tpch/9.sql b/googlesql/examples/zetasql/examples/tpch/9.sql new file mode 100644 index 0000000..2275c12 --- /dev/null +++ b/googlesql/examples/zetasql/examples/tpch/9.sql @@ -0,0 +1,48 @@ +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +SELECT + nation, + o_year, + sum(amount) AS sum_profit +FROM + ( + SELECT + n_name AS nation, + EXTRACT(year FROM o_orderdate) AS o_year, + l_extendedprice * (1 - l_discount) - ps_supplycost * l_quantity AS amount + FROM + part, + supplier, + lineitem, + partsupp, + orders, + nation + WHERE + s_suppkey = l_suppkey + AND ps_suppkey = l_suppkey + AND ps_partkey = l_partkey + AND p_partkey = l_partkey + AND o_orderkey = l_orderkey + AND s_nationkey = n_nationkey + AND p_name LIKE '%tomato%' + ) AS profit +GROUP BY + nation, + o_year +ORDER BY + nation, + o_year DESC; diff --git a/googlesql/examples/zetasql/parser/testdata/alter_column_set_drop_default.sql b/googlesql/examples/zetasql/parser/testdata/alter_column_set_drop_default.sql new file mode 100644 index 0000000..581c56f --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/alter_column_set_drop_default.sql @@ -0,0 +1,6 @@ +ALTER TABLE foo ALTER COLUMN bar SET DEFAULT 'my default'; +ALTER TABLE foo ALTER COLUMN IF EXISTS bar SET DEFAULT 12345; +ALTER TABLE foo ALTER COLUMN `SELECT` SET DEFAULT STRUCT(1, 2); +ALTER TABLE foo ALTER COLUMN `collate` SET DEFAULT `collate`(y, 'x'); +ALTER TABLE foo ALTER COLUMN bar DROP DEFAULT; +ALTER TABLE IF EXISTS foo ALTER COLUMN bar DROP DEFAULT; diff --git a/googlesql/examples/zetasql/parser/testdata/alter_column_type.sql b/googlesql/examples/zetasql/parser/testdata/alter_column_type.sql new file mode 100644 index 0000000..5d98eeb --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/alter_column_type.sql @@ -0,0 +1,16 @@ +ALTER TABLE foo ALTER COLUMN bar SET DATA TYPE STRING; +ALTER TABLE foo ALTER COLUMN IF EXISTS bar SET DATA TYPE STRING; +ALTER TABLE foo ALTER COLUMN `CAST` SET DATA TYPE STRING; +ALTER TABLE foo ALTER COLUMN bar SET OPTIONS(); +ALTER TABLE foo ALTER COLUMN bar SET OPTIONS(foo = "bar"); +ALTER TABLE foo ALTER COLUMN IF EXISTS bar SET OPTIONS(foo = "bar"); +ALTER TABLE foo ALTER COLUMN bar SET OPTIONS(foo = bar); +ALTER TABLE foo ALTER COLUMN bar DROP NOT NULL; +ALTER TABLE IF EXISTS foo ALTER COLUMN bar DROP NOT NULL; +ALTER TABLE foo ALTER COLUMN IF EXISTS bar DROP NOT NULL; +ALTER TABLE foo ALTER COLUMN IF EXISTS bar SET DATA TYPE STRING NOT NULL OPTIONS(description = "new description"); +ALTER TABLE foo ALTER COLUMN IF EXISTS bar SET DATA TYPE STRING COLLATE 'unicode:ci'; +ALTER TABLE foo ALTER COLUMN IF EXISTS bar SET DATA TYPE ARRAY< STRING COLLATE 'unicode:ci' >; +ALTER TABLE foo ALTER COLUMN IF EXISTS bar SET DATA TYPE STRUCT< a STRING COLLATE 'unicode:ci', b NUMERIC >; +ALTER TABLE foo ALTER COLUMN bar DROP GENERATED; +ALTER TABLE IF EXISTS foo ALTER COLUMN bar DROP GENERATED; diff --git a/googlesql/examples/zetasql/parser/testdata/alter_row_access_policy.sql b/googlesql/examples/zetasql/parser/testdata/alter_row_access_policy.sql new file mode 100644 index 0000000..dd32426 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/alter_row_access_policy.sql @@ -0,0 +1,18 @@ +ALTER ROW ACCESS POLICY p1 ON t1 RENAME TO p2; +ALTER ROW ACCESS POLICY p1 ON t1 GRANT TO ('foo@google.com'); +ALTER ROW ACCESS POLICY p1 ON t1 FILTER USING (c1 > 0); +ALTER ROW ACCESS POLICY p1 ON t1 REVOKE FROM ('bar@google.com'); +ALTER ROW ACCESS POLICY p1 ON t1 REVOKE FROM ALL; +ALTER ROW ACCESS POLICY p1 ON t1 FILTER USING (c = "foo"); +ALTER ROW ACCESS POLICY p1 ON t1 GRANT TO ("foo@google.com"); +ALTER ROW ACCESS POLICY IF EXISTS t1 ON t2 REVOKE FROM ALL; +ALTER ROW ACCESS POLICY p1 ON n1.t1 GRANT TO ('foo@google.com', 'mdbgroup/bar'); +ALTER ROW ACCESS POLICY p1 ON t1 GRANT TO ('foo@google.com', "mdbuser/bar"); +ALTER ROW ACCESS POLICY p1 ON t1 GRANT TO (@param_user); +ALTER ROW ACCESS POLICY p1 ON t1 GRANT TO (@@sysvar); +ALTER ROW ACCESS POLICY p1 ON t1 FILTER USING (c1 = 'foo'); +ALTER ROW ACCESS POLICY p1 ON t1 REVOKE FROM ('foo@google.com', "mdbuser/bar"); +ALTER ROW ACCESS POLICY p1 ON t1 REVOKE FROM (@param_user); +ALTER ALL ROW ACCESS POLICIES ON t1 REVOKE FROM ("foo@google.com", "bar@google.com"); +ALTER ALL ROW ACCESS POLICIES ON t1 REVOKE FROM ALL; +ALTER ALL ROW ACCESS POLICIES ON namespace.`all`.t1 REVOKE FROM ("foo@google.com"); diff --git a/googlesql/examples/zetasql/parser/testdata/alter_set_options.sql b/googlesql/examples/zetasql/parser/testdata/alter_set_options.sql new file mode 100644 index 0000000..a96e1d3 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/alter_set_options.sql @@ -0,0 +1,9 @@ +ALTER MATERIALIZED VIEW adsdw.foo SET OPTIONS(), SET OPTIONS(), SET OPTIONS(); +ALTER APPROX VIEW IF EXISTS adsdw.foo SET OPTIONS(); +ALTER APPROX VIEW adsdw.foo SET OPTIONS(quota_accounting_owner = 'adsdw-etl@google.com'); +ALTER APPROX VIEW adsdw.foo SET OPTIONS(ttl_seconds = 3600); +ALTER APPROX VIEW adsdw.foo SET OPTIONS(ttl_seconds = NULL); +ALTER APPROX VIEW foo SET OPTIONS(quota_accounting_owner = 'adsdw-etl@google.com', ttl_seconds = 3600); +ALTER MATERIALIZED VIEW foo SET OPTIONS(quota_accounting_owner = 'adsdw-etl@google.com', quota_accounting_owner = + 'adsdw-etl@google.com'); +ALTER MODEL foo SET OPTIONS(a = 'a', b = 1), SET OPTIONS(c = 'c'), SET OPTIONS(a = 'a', b = 1); diff --git a/googlesql/examples/zetasql/parser/testdata/alter_table_add_check_constraint.sql b/googlesql/examples/zetasql/parser/testdata/alter_table_add_check_constraint.sql new file mode 100644 index 0000000..70ece85 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/alter_table_add_check_constraint.sql @@ -0,0 +1,14 @@ +ALTER TABLE foo.bar ADD CONSTRAINT a_is_positive CHECK(a > 0) ENFORCED; +ALTER TABLE foo.bar ADD CONSTRAINT a_is_positive CHECK(a > 0) ENFORCED; +ALTER TABLE foo.bar ADD CONSTRAINT a_is_positive CHECK(a > 0) ENFORCED; +ALTER TABLE foo.bar ADD CONSTRAINT constraint CHECK(a > 0) ENFORCED; +ALTER TABLE foo.bar ADD CONSTRAINT IF NOT EXISTS constraint CHECK(a > 0) ENFORCED; +ALTER TABLE foo.bar ADD CONSTRAINT check CHECK(a > 0) ENFORCED; +ALTER TABLE foo.bar ADD CONSTRAINT IF NOT EXISTS check CHECK(a > 0) ENFORCED; +ALTER TABLE foo.bar ADD CONSTRAINT int64 CHECK(a > 0) ENFORCED; +ALTER TABLE foo.bar ADD CONSTRAINT IF NOT EXISTS int64 CHECK(a > 0) ENFORCED; +ALTER TABLE foo.bar ADD CHECK(a > 0) ENFORCED; +ALTER TABLE foo.bar ADD CHECK(a > 0) ENFORCED; +ALTER TABLE foo.bar ADD CHECK(a > 0) NOT ENFORCED; +ALTER TABLE add ADD CONSTRAINT IF NOT EXISTS int64 CHECK(a > 0) ENFORCED; +ALTER TABLE constraint ADD CONSTRAINT IF NOT EXISTS int64 CHECK(a > 0) ENFORCED; diff --git a/googlesql/examples/zetasql/parser/testdata/alter_table_add_column.sql b/googlesql/examples/zetasql/parser/testdata/alter_table_add_column.sql new file mode 100644 index 0000000..ddae1b0 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/alter_table_add_column.sql @@ -0,0 +1,17 @@ +ALTER TABLE foo ADD COLUMN bar STRING; +ALTER TABLE IF EXISTS foo ADD COLUMN bar INT64; +ALTER TABLE foo ADD COLUMN IF NOT EXISTS bar INT64; +ALTER TABLE IF EXISTS foo ADD COLUMN IF NOT EXISTS bar INT64; +ALTER TABLE foo ADD COLUMN bar INT64 PRECEDING baz; +ALTER TABLE foo ADD COLUMN IF NOT EXISTS bar STRING FOLLOWING baz; +ALTER TABLE foo ADD COLUMN bar STRING NOT NULL FOLLOWING baz; +ALTER TABLE foo ADD COLUMN bar STRING FILL USING a + b; +ALTER TABLE foo ADD COLUMN bar STRING NOT NULL PRIMARY KEY NOT ENFORCED FILL USING a + b; +ALTER TABLE foo ADD COLUMN bar STRING NOT NULL PRIMARY KEY FILL USING a + b; +ALTER TABLE foo ADD COLUMN bar STRING FOLLOWING baz FILL USING a + b; +ALTER TABLE foo ADD COLUMN bar STRING FILL USING a + b, ADD COLUMN baz INT64; +ALTER TABLE foo ADD COLUMN column STRING FILL USING a + b, ADD COLUMN column STRING PRIMARY KEY, ADD COLUMN `union` INT64; +ALTER TABLE foo ADD COLUMN column STRING COLLATE 'unicode:ci'; +ALTER TABLE foo ADD COLUMN column STRING COLLATE @@a; +ALTER TABLE foo ADD COLUMN column STRING COLLATE ?; +ALTER TABLE foo ADD COLUMN bar STRING DEFAULT "default string"; diff --git a/googlesql/examples/zetasql/parser/testdata/alter_table_add_foreign_key.sql b/googlesql/examples/zetasql/parser/testdata/alter_table_add_foreign_key.sql new file mode 100644 index 0000000..780b821 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/alter_table_add_foreign_key.sql @@ -0,0 +1,13 @@ +ALTER TABLE foo ADD FOREIGN KEY(A) REFERENCES T(B) MATCH SIMPLE ON UPDATE NO ACTION ON DELETE NO ACTION ENFORCED OPTIONS(); +ALTER TABLE foo ADD FOREIGN KEY(A) REFERENCES T(B) MATCH SIMPLE ON UPDATE NO ACTION ON DELETE NO ACTION ENFORCED; +ALTER TABLE foo ADD FOREIGN KEY(A) REFERENCES T(B) MATCH SIMPLE ON UPDATE NO ACTION ON DELETE NO ACTION NOT ENFORCED; +ALTER TABLE foo ADD CONSTRAINT bar FOREIGN KEY(A) REFERENCES T(B) MATCH SIMPLE ON UPDATE NO ACTION ON DELETE NO ACTION ENFORCED; +ALTER TABLE foo ADD CONSTRAINT foreign FOREIGN KEY(A) REFERENCES T(B) MATCH SIMPLE ON UPDATE NO ACTION ON DELETE NO ACTION ENFORCED; +ALTER TABLE foo ADD FOREIGN KEY(A, B) REFERENCES T(A, B) MATCH SIMPLE ON UPDATE NO ACTION ON DELETE NO ACTION ENFORCED; +ALTER TABLE foo ADD FOREIGN KEY(A) REFERENCES T(B) MATCH SIMPLE ON UPDATE NO ACTION ON DELETE CASCADE ENFORCED; +ALTER TABLE foo ADD FOREIGN KEY(A) REFERENCES T(B) MATCH SIMPLE ON UPDATE NO ACTION ON DELETE NO ACTION ENFORCED; +ALTER TABLE foo ADD FOREIGN KEY(A) REFERENCES T(B) MATCH SIMPLE ON UPDATE NO ACTION ON DELETE NO ACTION ENFORCED; +ALTER TABLE foo ADD FOREIGN KEY(A) REFERENCES T(B) MATCH FULL ON UPDATE NO ACTION ON DELETE NO ACTION ENFORCED; +ALTER TABLE foo ADD FOREIGN KEY(A) REFERENCES T(B) MATCH SIMPLE ON UPDATE NO ACTION ON DELETE NO ACTION ENFORCED; +ALTER TABLE foo ADD FOREIGN KEY(A) REFERENCES T(B) MATCH SIMPLE ON UPDATE CASCADE ON DELETE NO ACTION ENFORCED; +ALTER TABLE foo ADD FOREIGN KEY(A) REFERENCES T(B) MATCH FULL ON UPDATE CASCADE ON DELETE CASCADE ENFORCED; diff --git a/googlesql/examples/zetasql/parser/testdata/alter_table_alter_constraint.sql b/googlesql/examples/zetasql/parser/testdata/alter_table_alter_constraint.sql new file mode 100644 index 0000000..27572c5 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/alter_table_alter_constraint.sql @@ -0,0 +1,6 @@ +ALTER TABLE foo ALTER CONSTRAINT bar ENFORCED; +ALTER TABLE foo ALTER CONSTRAINT IF EXISTS bar ENFORCED; +ALTER TABLE foo ALTER CONSTRAINT bar NOT ENFORCED; +ALTER TABLE foo ALTER CONSTRAINT bar SET OPTIONS(); +ALTER TABLE foo ALTER CONSTRAINT IF EXISTS bar SET OPTIONS(opt_a = 1); +ALTER TABLE foo ALTER CONSTRAINT bar SET OPTIONS(opt_a = 1, opt_b = 2); diff --git a/googlesql/examples/zetasql/parser/testdata/alter_table_drop_column.sql b/googlesql/examples/zetasql/parser/testdata/alter_table_drop_column.sql new file mode 100644 index 0000000..e0deb5d --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/alter_table_drop_column.sql @@ -0,0 +1,7 @@ +ALTER TABLE foo.bar DROP COLUMN baz; +ALTER TABLE IF EXISTS foo.bar DROP COLUMN baz; +ALTER TABLE foo.bar DROP COLUMN IF EXISTS baz; +ALTER TABLE column DROP COLUMN baz; +ALTER TABLE column DROP COLUMN check; +ALTER TABLE column DROP COLUMN column; +ALTER TABLE column DROP COLUMN `union`; diff --git a/googlesql/examples/zetasql/parser/testdata/alter_table_drop_constraint.sql b/googlesql/examples/zetasql/parser/testdata/alter_table_drop_constraint.sql new file mode 100644 index 0000000..588ff09 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/alter_table_drop_constraint.sql @@ -0,0 +1,5 @@ +ALTER TABLE foo.bar DROP CONSTRAINT baz; +ALTER TABLE foo.bar DROP CONSTRAINT IF EXISTS baz; +ALTER TABLE constraint DROP CONSTRAINT baz; +ALTER TABLE constraint DROP CONSTRAINT check; +ALTER TABLE constraint DROP CONSTRAINT constraint; diff --git a/googlesql/examples/zetasql/parser/testdata/alter_table_multiple_actions.sql b/googlesql/examples/zetasql/parser/testdata/alter_table_multiple_actions.sql new file mode 100644 index 0000000..7354edb --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/alter_table_multiple_actions.sql @@ -0,0 +1,15 @@ +ALTER TABLE foo SET OPTIONS(opt_t = 1), ADD CONSTRAINT a_is_positive CHECK(a > 0) ENFORCED, ALTER CONSTRAINT bar ENFORCED, + ALTER CONSTRAINT baz SET OPTIONS(opt_a = true); +ALTER TABLE foo SET OPTIONS(opt_a = true), ADD CHECK(a > 0) ENFORCED; +ALTER TABLE foo SET OPTIONS(opt_a = true), ALTER CONSTRAINT bar NOT ENFORCED; +ALTER TABLE foo SET OPTIONS(opt_a = true), ADD ROW DELETION POLICY(x > 1000); +ALTER TABLE foo ADD ROW DELETION POLICY(x > 1000), DROP ROW DELETION POLICY; +ALTER TABLE foo SET OPTIONS(opt_a = true), ALTER CONSTRAINT bar SET OPTIONS(opt_b = 1); +ALTER TABLE foo ADD CHECK(a > 0) ENFORCED, ALTER CONSTRAINT bar NOT ENFORCED; +ALTER TABLE foo ALTER CONSTRAINT bar NOT ENFORCED, ALTER CONSTRAINT bar SET OPTIONS(opt_a = 1); +ALTER TABLE foo ADD FOREIGN KEY(A) REFERENCES T(B) MATCH SIMPLE ON UPDATE NO ACTION ON DELETE NO ACTION ENFORCED, + ADD CHECK(col_a > 0) ENFORCED; +ALTER TABLE foo ADD CONSTRAINT fk_A FOREIGN KEY(A) REFERENCES T(B) MATCH SIMPLE ON UPDATE NO ACTION ON DELETE NO ACTION ENFORCED, + ALTER CONSTRAINT a_gt_zero NOT ENFORCED; +ALTER TABLE foo ADD CONSTRAINT fk_A FOREIGN KEY(A) REFERENCES T(B) MATCH SIMPLE ON UPDATE NO ACTION ON DELETE NO ACTION ENFORCED, + DROP CONSTRAINT a_gt_zero; diff --git a/googlesql/examples/zetasql/parser/testdata/alter_table_rename_to.sql b/googlesql/examples/zetasql/parser/testdata/alter_table_rename_to.sql new file mode 100644 index 0000000..b5c1773 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/alter_table_rename_to.sql @@ -0,0 +1,3 @@ +ALTER TABLE foo RENAME TO bar; +ALTER TABLE IF EXISTS foo RENAME TO bar; +ALTER TABLE foo RENAME TO `foo.bar`; diff --git a/googlesql/examples/zetasql/parser/testdata/alter_table_ttl.sql b/googlesql/examples/zetasql/parser/testdata/alter_table_ttl.sql new file mode 100644 index 0000000..0409d56 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/alter_table_ttl.sql @@ -0,0 +1,3 @@ +ALTER TABLE T ADD ROW DELETION POLICY IF NOT EXISTS (c > 1000); +ALTER TABLE T REPLACE ROW DELETION POLICY IF EXISTS (c > 1000); +ALTER TABLE T DROP ROW DELETION POLICY IF EXISTS; diff --git a/googlesql/examples/zetasql/parser/testdata/analyze.sql b/googlesql/examples/zetasql/parser/testdata/analyze.sql new file mode 100644 index 0000000..f91a537 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/analyze.sql @@ -0,0 +1,12 @@ +ANALYZE OPTIONS(p1 = a1, p2 = a2) T(a, b, c); +ANALYZE OPTIONS(p1 = a1, p2 = a2) T(a, b, c), T2(a, b, c); +ANALYZE OPTIONS(p1 = a1, p2 = a2) T, T2(a, b, c); +ANALYZE T(a, b, c); +ANALYZE T(a, b, c), T2(a); +ANALYZE T; +ANALYZE T, T2; +ANALYZE OPTIONS(); +ANALYZE T, OPTIONS; +ANALYZE OPTIONS(a = b) Options(a, b, c); +ANALYZE T, OPTIONS(a, b, c); +ANALYZE OPTIONS(p1 = a1, p2 = a2); diff --git a/googlesql/examples/zetasql/parser/testdata/assert.sql b/googlesql/examples/zetasql/parser/testdata/assert.sql new file mode 100644 index 0000000..ad094f2 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/assert.sql @@ -0,0 +1,27 @@ +ASSERT TRUE; +ASSERT(5 + a); +ASSERT( + SELECT + 1 +) = 1 AS "simple test"; +ASSERT NOT EXISTS( + SELECT + 1 +); +ASSERT @param = 1 AS "param test"; +ASSERT @@sysvar = 1 AS "sysvar test"; +ASSERT "123" IN ("123", "456"); +ASSERT IS_NAN(NULL) OR ENDS_WITH("suffix", "fix") AS "abc"; +ASSERT "123" IS NOT NULL; +ASSERT CASE TRUE + WHEN TRUE THEN FALSE +END; +ASSERT 123 BETWEEN 1 AND 456; +ASSERT( + SELECT + IS_NAN(NAN) +); +ASSERT(ASSERT(( + SELECT + TRUE + ))); diff --git a/googlesql/examples/zetasql/parser/testdata/batch.sql b/googlesql/examples/zetasql/parser/testdata/batch.sql new file mode 100644 index 0000000..482bc56 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/batch.sql @@ -0,0 +1,4 @@ +START BATCH; +START BATCH dDL; +RUN BATCH; +ABORT BATCH; diff --git a/googlesql/examples/zetasql/parser/testdata/call.sql b/googlesql/examples/zetasql/parser/testdata/call.sql new file mode 100644 index 0000000..b2520d4 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/call.sql @@ -0,0 +1,14 @@ +CALL myprocedure(); +CALL schema.myprocedure(); +CALL myprocedure(1 + 2, "a", CAST(NULL AS string)); +CALL myprocedure(MODEL my.model); +CALL myprocedure(CONNECTION DEFAULT); +CALL myprocedure(CONNECTION my.connection); +CALL myprocedure(TABLE my.table, ( + SELECT + * + FROM + my.another_table +), mytvf(1, 2)); +CALL myprocedure(@test_param_bool); +CALL myprocedure(@@sysvar); diff --git a/googlesql/examples/zetasql/parser/testdata/clone_data.sql b/googlesql/examples/zetasql/parser/testdata/clone_data.sql new file mode 100644 index 0000000..e345083 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/clone_data.sql @@ -0,0 +1,17 @@ +CLONE DATA INTO t +FROM src; +CLONE DATA INTO a.b +FROM foo.bar; +CLONE DATA INTO `a.b-c` +FROM `foo-bar`; +CLONE DATA INTO ds.t +FROM ds.s + WHERE + timestamp = NOW(); +CLONE DATA INTO a.b +FROM ds.x +UNION ALL ds.y +UNION ALL ds.z; +CLONE DATA INTO a.b +FROM foo.bar + FOR SYSTEM_TIME AS OF TIMESTAMP_SUB(`CURRENT_TIMESTAMP`(), INTERVAL 1 HOUR); diff --git a/googlesql/examples/zetasql/parser/testdata/create_constant.sql b/googlesql/examples/zetasql/parser/testdata/create_constant.sql new file mode 100644 index 0000000..1e302b8 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/create_constant.sql @@ -0,0 +1,20 @@ +CREATE CONSTANT foo = 5; +CREATE CONSTANT a.b.c = 'str'; +CREATE CONSTANT d.e = a + b; +CREATE CONSTANT d.e = @param; +CREATE CONSTANT d.e = @@sysvar; +CREATE CONSTANT d.e = NULL; +CREATE CONSTANT d.e = NULL; +CREATE CONSTANT d.e = CAST(NULL AS STRING); +CREATE CONSTANT a = ( + SELECT + 1 + FROM + foo +); +CREATE PRIVATE CONSTANT a = 0; +CREATE OR REPLACE CONSTANT constant = 1; +CREATE CONSTANT IF NOT EXISTS foo = 1; +CREATE OR REPLACE PRIVATE CONSTANT IF NOT EXISTS a = 0; +CREATE CONSTANT `function` = 5; +CREATE CONSTANT table = 'a'; diff --git a/googlesql/examples/zetasql/parser/testdata/create_database.sql b/googlesql/examples/zetasql/parser/testdata/create_database.sql new file mode 100644 index 0000000..ab2920e --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/create_database.sql @@ -0,0 +1,7 @@ +CREATE DATABASE db; +CREATE DATABASE a.b.c.db; +CREATE DATABASE database; +CREATE DATABASE db OPTIONS(db_option = 1); +CREATE DATABASE a.b.c.db OPTIONS(db_option = 1); +CREATE DATABASE db OPTIONS(option_1 = 1, option_2 = '2'); +CREATE DATABASE OPTIONS OPTIONS(option_1 = 1, option_2 = '2'); diff --git a/googlesql/examples/zetasql/parser/testdata/create_external_schema.sql b/googlesql/examples/zetasql/parser/testdata/create_external_schema.sql new file mode 100644 index 0000000..a00b105 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/create_external_schema.sql @@ -0,0 +1,16 @@ +CREATE EXTERNAL SCHEMA foo WITH CONNECTION bar.baz +OPTIONS(); +CREATE EXTERNAL SCHEMA foo WITH CONNECTION DEFAULT +OPTIONS(); +CREATE EXTERNAL SCHEMA foo WITH CONNECTION bar.baz +OPTIONS(); +CREATE EXTERNAL SCHEMA `WITH CONNECTION` WITH CONNECTION bar.baz +OPTIONS(); +CREATE OR REPLACE EXTERNAL SCHEMA IF NOT EXISTS foo.bar WITH CONNECTION baz +OPTIONS(); +CREATE EXTERNAL SCHEMA foo WITH CONNECTION bar.baz +OPTIONS(a = b, c = "def"); +CREATE PRIVATE EXTERNAL SCHEMA foo WITH CONNECTION bar +OPTIONS(); +CREATE EXTERNAL SCHEMA foo +OPTIONS(); diff --git a/googlesql/examples/zetasql/parser/testdata/create_external_table.sql b/googlesql/examples/zetasql/parser/testdata/create_external_table.sql new file mode 100644 index 0000000..ff06a8d --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/create_external_table.sql @@ -0,0 +1,76 @@ +CREATE EXTERNAL TABLE t1 OPTIONS(a = b, c = "def"); +CREATE PRIVATE EXTERNAL TABLE a.b.c.t1 OPTIONS(size = 10); +CREATE OR REPLACE TEMP EXTERNAL TABLE IF NOT EXISTS T OPTIONS(); +CREATE EXTERNAL TABLE `function` OPTIONS(); +CREATE EXTERNAL TABLE `function` OPTIONS(); +CREATE PRIVATE EXTERNAL TABLE t +( + x int64 +) OPTIONS(); +CREATE OR REPLACE TEMP EXTERNAL TABLE IF NOT EXISTS t +( + x int64 +) OPTIONS(); +CREATE EXTERNAL TABLE t1 +( + element1 bool, + element2 string +) OPTIONS(a = '{"jsonkey": "jsonvalue"}', c = "def"); +CREATE EXTERNAL TABLE t1 +( + x int64 NOT NULL +) OPTIONS(a = b); +CREATE EXTERNAL TABLE projectid.datasetid.tablename +( + x int64, + y string, + z string, + PRIMARY KEY(x, y ASC, z DESC) +) OPTIONS(a = b); +CREATE EXTERNAL TABLE projectid.datasetid.tablename WITH PARTITION COLUMNS OPTIONS(); +CREATE EXTERNAL TABLE projectid.datasetid.tablename +( + x int64 +) WITH PARTITION COLUMNS( + y int64, + z string +) OPTIONS(); +CREATE EXTERNAL TABLE projectid.datasetid.tablename WITH PARTITION COLUMNS( + y int64, + PRIMARY KEY(y) +) OPTIONS(); +CREATE EXTERNAL TABLE projectid.datasetid.tablename +( + x int64, + PRIMARY KEY(x) +) WITH PARTITION COLUMNS( + CHECK(x > 0) ENFORCED +) OPTIONS(); +CREATE EXTERNAL TABLE projectid.datasetid.tablename +( + x int64 +) WITH CONNECTION DEFAULT OPTIONS(x = foo); +CREATE EXTERNAL TABLE projectid.datasetid.tablename +( + x int64 +) WITH CONNECTION conn_1 OPTIONS(x = foo); +CREATE EXTERNAL TABLE projectid.datasetid.tablename +( + x int64 +) WITH CONNECTION proj.loc.conn_id OPTIONS(x = foo); +CREATE EXTERNAL TABLE projectid.datasetid.tablename +( + x int64 +) WITH PARTITION COLUMNS WITH CONNECTION `project.country-region-5.connection_1` OPTIONS(x = bar); +CREATE EXTERNAL TABLE t +( + x int64 +) WITH PARTITION COLUMNS( + y int64, + PRIMARY KEY(y DESC) +) WITH CONNECTION a.b.c OPTIONS(x = baz); +CREATE EXTERNAL TABLE t1 +( + a int32, + PRIMARY KEY(a DESC) +) OPTIONS(); diff --git a/googlesql/examples/zetasql/parser/testdata/create_function.sql b/googlesql/examples/zetasql/parser/testdata/create_function.sql new file mode 100644 index 0000000..ba0db44 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/create_function.sql @@ -0,0 +1,117 @@ +CREATE FUNCTION myfunc(); +CREATE FUNCTION myfunc() +RETURNS string LANGUAGE testlang; +CREATE FUNCTION mypackage.myfunc() +RETURNS string LANGUAGE testlang; +CREATE PRIVATE FUNCTION myfunc() +RETURNS string LANGUAGE testlang; +CREATE FUNCTION myfunc() +RETURNS string VOLATILE LANGUAGE testlang; +CREATE FUNCTION deterministic() +RETURNS immutable STABLE LANGUAGE volatile; +CREATE FUNCTION IF NOT EXISTS myfunc() +RETURNS string LANGUAGE testlang; +CREATE OR REPLACE FUNCTION myfunc() +RETURNS string LANGUAGE testlang; +CREATE TEMP FUNCTION IF NOT EXISTS myfunc() +RETURNS string LANGUAGE testlang; +CREATE TEMP FUNCTION IF NOT EXISTS myfunc() +RETURNS string LANGUAGE testlang; +CREATE FUNCTION mypackage.myfunc(param_a int32) +RETURNS STRUCT< x string, y boolean > LANGUAGE testlang; +CREATE FUNCTION mypackage.myfunc(param_a int32) +RETURNS a.b.c LANGUAGE testlang; +CREATE FUNCTION mypackage.myfunc(a int32, b STRUCT< x string, y int32 >, c ARRAY< boolean >) +RETURNS string LANGUAGE testlang; +CREATE FUNCTION fn(s string) +RETURNS string LANGUAGE testlang AS """ return + "presto!" + s + '\n'; +"""; +CREATE FUNCTION fn(s string) +RETURNS string LANGUAGE testlang OPTIONS + (a = b, bruce = lee) AS "return 'a';"; +CREATE FUNCTION fn(s string) +RETURNS string LANGUAGE testlang OPTIONS + (a = b, bruce = lee) AS "return 'a';"; +CREATE FUNCTION fn(s string) +RETURNS string; +CREATE FUNCTION fn(string) +RETURNS string LANGUAGE testlang AS "return 'a';"; +CREATE FUNCTION fn(string, s string, int32, i int32) +RETURNS string LANGUAGE testlang AS "return 'a'"; +CREATE FUNCTION mypackage.myfunc(int32 AS alias) +RETURNS string LANGUAGE testlang; +CREATE FUNCTION mypackage.myfunc(int32 alias) +RETURNS string LANGUAGE testlang; +CREATE FUNCTION mypackage.myfunc(x int32 AS alias) +RETURNS string LANGUAGE testlang; +CREATE FUNCTION mypackage.myfunc(x int32 AS alias NOT AGGREGATE) +RETURNS string LANGUAGE testlang; +CREATE FUNCTION sql_func(x int32 AS type_alias, y type_alias) +RETURNS int32 AS ( + ( + SELECT + CAST(1 AS type_alias) + x - y + ) +); +CREATE FUNCTION myfunc() +RETURNS interval; +CREATE FUNCTION myfunc(a int64, b string DEFAULT "abc") +RETURNS double; +CREATE FUNCTION myfunc(a int64 DEFAULT -314, b string DEFAULT "abc", c double DEFAULT 3.14) +RETURNS double; +CREATE FUNCTION myfunc(a int64, b ANY TYPE DEFAULT "abc", c ANY TYPE DEFAULT 3.14) +RETURNS double; +CREATE FUNCTION myfunc() +RETURNS string REMOTE; +CREATE FUNCTION myfunc() +RETURNS string REMOTE WITH CONNECTION myconn; +CREATE FUNCTION myfunc() +RETURNS string REMOTE WITH CONNECTION DEFAULT; +CREATE FUNCTION myfunc() +RETURNS string REMOTE WITH CONNECTION `myconn-abc`; +CREATE FUNCTION myfunc() +RETURNS string REMOTE WITH CONNECTION myconn OPTIONS + (a = b, bruce = lee); +CREATE FUNCTION myfunc() +RETURNS string VOLATILE REMOTE; +CREATE FUNCTION myfunc() +RETURNS int LANGUAGE js REMOTE; +CREATE FUNCTION myfunc() +RETURNS int LANGUAGE js REMOTE WITH CONNECTION c; +CREATE FUNCTION myfunc() +RETURNS int REMOTE AS ( + 5 +); +CREATE FUNCTION remote(int remote) +RETURNS int REMOTE WITH CONNECTION remote; +CREATE FUNCTION returns_remote() +RETURNS remote AS ( + NULL +); +CREATE FUNCTION returns_remote() +RETURNS remote REMOTE; +CREATE FUNCTION my_func(x FUNCTION<() -> STRUCT< INT64 > >) +AS ( + x() +); +CREATE FUNCTION my_func(x FUNCTION<(STRUCT< INT64 >) -> INT64 >) +AS ( + x(1) +); +CREATE FUNCTION my_func(x FUNCTION<(STRUCT< INT64 >) -> INT64 >) +AS ( + x(1) +); +CREATE FUNCTION my_func(x FUNCTION<(STRUCT< INT64 >, STRUCT< INT64 >) -> INT64 >) +AS ( + x(1, 2) +); +CREATE FUNCTION `function`(`function` FUNCTION<() -> INT64 >) +AS ( + `function`() +); +CREATE FUNCTION func(x FUNCTION<() -> INT64 > (0)) +AS ( + 1 +); diff --git a/googlesql/examples/zetasql/parser/testdata/create_index.sql b/googlesql/examples/zetasql/parser/testdata/create_index.sql new file mode 100644 index 0000000..538c0ab --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/create_index.sql @@ -0,0 +1,72 @@ +CREATE INDEX a.b.i1 ON c.d.t1(a, b, c) +OPTIONS(x = 1, y = 2); +CREATE INDEX i1 ON t1(a DESC, b ASC); +CREATE INDEX i1 ON t1(a DESC NULLS LAST); +CREATE UNIQUE INDEX i1 ON t1(a, b); +CREATE INDEX i1 ON t1(a.b.c, e, c * d); +CREATE OR REPLACE UNIQUE VECTOR INDEX IF NOT EXISTS i1 ON t1(a) +OPTIONS(); +CREATE INDEX a.b.i1 ON c.d.t1 AS foo(a, b, c) +OPTIONS(x = 1, y = 2); +CREATE INDEX a.b.i1 ON c.d.t1 AS foo +UNNEST(a) +(a, b, c) +OPTIONS(x = 1, y = 2); +CREATE INDEX a.b.i1 ON c.d.t1 AS foo +UNNEST(a) AS bar +(a, b, c) +OPTIONS(x = 1, y = 2); +CREATE INDEX a.b.i1 ON c.d.t1 AS foo +UNNEST(a) AS bar WITH OFFSET +(a, b, c) +OPTIONS(x = 1, y = 2); +CREATE INDEX a.b.i1 ON c.d.t1 AS foo +UNNEST(a) AS bar WITH OFFSET AS offset +(a, b, c) +OPTIONS(x = 1, y = 2); +CREATE INDEX a.b.i1 ON c.d.t1 AS foo +UNNEST(x.y.z) AS bar +(bar) +OPTIONS(x = 1, y = 2); +CREATE INDEX a.b.i1 ON c.d.t1 AS foo +UNNEST(array_concat(ARRAY[1], ARRAY[2])) AS bar +(bar) +OPTIONS(x = 1, y = 2); +CREATE INDEX a.b.i1 ON c.d.t1 AS foo +UNNEST(a) AS bar1 WITH OFFSET AS offset1 UNNEST(b) AS bar2 WITH OFFSET AS offset2 +(a, b, c) +OPTIONS(x = 1, y = 2); +CREATE INDEX i1 ON t1(a) +STORING(b) +OPTIONS(x = 1, y = 2); +CREATE INDEX i1 ON t1(a) +STORING(b, c) +OPTIONS(x = 1, y = 2); +CREATE INDEX i1 ON t1(a) +STORING(b1.b2); +CREATE INDEX i1 ON t1(a) +STORING(b + 1); +CREATE SEARCH INDEX i1 ON t1(`ALL COLUMNS`) +OPTIONS(); +CREATE SEARCH INDEX i1 ON t1(ALL COLUMNS) +OPTIONS(); +CREATE SEARCH INDEX i1 ON t1(ALL COLUMNS) +OPTIONS(key = value); +CREATE SEARCH INDEX i1 ON t1('ALL', COLUMNS) +OPTIONS(); +CREATE SEARCH INDEX i1 ON t1(a) +STORING(s) +PARTITION BY a +OPTIONS(); +CREATE VECTOR INDEX i1 ON t1(a) +PARTITION BY p1, p2 +OPTIONS(); +CREATE SEARCH INDEX i1 ON t1(a) +PARTITION BY DATE_TRUNC(_PARTITIONTIME, MONTH) +OPTIONS(); +CREATE SEARCH INDEX i1 ON t1(a OPTIONS()); +CREATE SEARCH INDEX i1 ON t1(a OPTIONS(k1 = v1)); +CREATE SEARCH INDEX i1 ON t1(c1 OPTIONS(k1 = v1), c2 OPTIONS()); +CREATE SEARCH INDEX i1 ON t1(c1 OPTIONS(k1 = v1), c2 OPTIONS(k1 = v1, k2 = v2)); +CREATE SEARCH INDEX i1 ON t1(ALL COLUMNS WITH COLUMN OPTIONS(c1 OPTIONS())); +CREATE SEARCH INDEX i1 ON t1(ALL COLUMNS WITH COLUMN OPTIONS(c1 OPTIONS(k1 = v1))); diff --git a/googlesql/examples/zetasql/parser/testdata/create_model.sql b/googlesql/examples/zetasql/parser/testdata/create_model.sql new file mode 100644 index 0000000..7e5d8cf --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/create_model.sql @@ -0,0 +1,236 @@ +CREATE MODEL t1; +CREATE MODEL t1 +INPUT( + i1 INT64, + i2 FLOAT64 +) +OUTPUT( + o1 BOOL +); +CREATE MODEL t1 REMOTE; +CREATE MODEL t1 WITH CONNECTION conn_1; +CREATE MODEL t1 WITH CONNECTION DEFAULT; +CREATE MODEL t1 REMOTE WITH CONNECTION conn_1; +CREATE MODEL t1 OPTIONS(abc = def); +CREATE MODEL t1 AS +SELECT + * +FROM + t2; +CREATE MODEL t1 TRANSFORM( + *) +AS +SELECT + * +FROM + t2; +CREATE MODEL t1 TRANSFORM( + * EXCEPT (a, b), + c) +AS +SELECT + * +FROM + t2; +CREATE MODEL t1 TRANSFORM( + * REPLACE (a AS b)) +AS +SELECT + * +FROM + t2; +CREATE MODEL t1 TRANSFORM( + a AS label) +AS +SELECT + * +FROM + t2; +CREATE MODEL t1 TRANSFORM( + a AS label) +AS +SELECT + * +FROM + t2; +CREATE MODEL t1 TRANSFORM( + ml.`cross`(a, b) AS c) +AS +SELECT + * +FROM + t2; +CREATE MODEL t1 TRANSFORM( + a, + 2 AS b) +AS +SELECT + * +FROM + t2; +CREATE PRIVATE MODEL pkg1.pkg2.`t 2` AS +SELECT + 1 AS a; +CREATE TEMP MODEL pkg1.pkg2.`t 2` AS +SELECT + 1 +FROM + t2 +UNION ALL +SELECT + 2 +FROM + t3 + CROSS JOIN + t4; +CREATE MODEL t3 AS +WITH + tt AS ( + SELECT + * + FROM + KeyValue + ) +SELECT + * +FROM + tt; +CREATE MODEL t4 OPTIONS(x = y) AS +WITH + t1 AS ( + SELECT + 1 + ), + t2 AS ( + SELECT + 2 + ) +SELECT + 3; +CREATE MODEL t4 OPTIONS(x = y); +CREATE MODEL tt OPTIONS(x = 1) AS +SELECT + 1; +CREATE MODEL tt TRANSFORM( + a AS b) +OPTIONS(x = 1) AS +SELECT + 1; +CREATE TEMP MODEL tt OPTIONS(x = 5, y = 'abc', z = @param, zz = ident, zzz = @@sysvar) AS +SELECT + 2; +CREATE MODEL tt OPTIONS() AS +SELECT + 2; +CREATE MODEL tt OPTIONS(x = 5.5, y = a, z = b.c) AS +SELECT + 2; +CREATE MODEL tt OPTIONS(y = 'b.c', z = `b.c`) AS +SELECT + 2; +CREATE MODEL options AS +SELECT + 1 AS x; +CREATE MODEL options OPTIONS(x = y) AS +SELECT + 1 AS x; +CREATE MODEL options OPTIONS(x = y) AS +SELECT + 1 AS x; +CREATE MODEL options OPTIONS(x = y) AS +SELECT + 1 AS x; +CREATE OR REPLACE MODEL xyz AS +( +SELECT + 1 +); +CREATE MODEL IF NOT EXISTS xyz AS +( +SELECT + 1 +); +CREATE OR REPLACE TEMP MODEL IF NOT EXISTS a.b.c OPTIONS(d = e) AS +SELECT + 1; +CREATE MODEL t AS +WITH + q AS ( + SELECT + 1 + ), + q2 AS ( + SELECT + * + FROM + q + ) +SELECT + * +FROM + q2; +CREATE MODEL t1 +INPUT( + i1 INT64, + i2 FLOAT64 +) +OUTPUT( + o1 BOOL +) REMOTE WITH CONNECTION conn_1 OPTIONS(abc = def); +CREATE MODEL t1 +INPUT( + i1 INT64, + i2 FLOAT64 +) +OUTPUT( + o1 BOOL +) TRANSFORM( + a, + 2 AS b) +REMOTE WITH CONNECTION conn_1 OPTIONS(abc = def) AS +SELECT + * +FROM + t2; +CREATE MODEL m AS +( +a1 AS ( + SELECT + * + FROM + t1 +)); +CREATE MODEL m AS +( +a1 AS ( + SELECT + * + FROM + t1 +), +a2 AS ( + SELECT + * + FROM + t2 +)); +CREATE MODEL m AS +( +SELECT + * +FROM + t1 +); +CREATE MODEL m AS +(WITH + a1 AS ( + SELECT + * + FROM + t1 + ) +SELECT + * +FROM + a1 +); diff --git a/googlesql/examples/zetasql/parser/testdata/create_procedure.sql b/googlesql/examples/zetasql/parser/testdata/create_procedure.sql new file mode 100644 index 0000000..46481fa --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/create_procedure.sql @@ -0,0 +1,81 @@ +CREATE PROCEDURE procedure_name() +BEGIN +END; +CREATE OR REPLACE TEMP PROCEDURE IF NOT EXISTS procedure_name() +OPTIONS + () +BEGIN +END; +CREATE PROCEDURE procedure_name() +OPTIONS + (a = 1, b = "2") +BEGIN +END; +CREATE PROCEDURE procedure_name(param_a string, param_b int32, param_c numeric, param_d TABLE< int32, +int32 >, param_e ANY TYPE, OUT param_f ANY TYPE, param_g ANY TABLE, INOUT param_h ANY TABLE) +BEGIN +END; +CREATE PROCEDURE procedure_name(OUT param_a string) +BEGIN + DECLARE a int32 ; + SET a = 1 ; + SET param_a = "test" ; +END; +CREATE PROCEDURE procedure_name(`OUT` int32) +BEGIN +END; +CREATE PROCEDURE procedure_name(OUT `OUT` int32) +BEGIN +END; +CREATE PROCEDURE procedure_name(param_a int32) +BEGIN +END; +CREATE PROCEDURE `OUT`(param_1 INT32) +BEGIN +END; +CREATE PROCEDURE procedure_name(param_a int32) +BEGIN + IF param_a > 0 THEN + RETURN ; + END IF ; +END; +CREATE PROCEDURE procedure_name() +BEGIN + SELECT + 1 + ; +END +; +CREATE PROCEDURE procedure_name() +BEGIN + SELECT + 1 + ; +END +; +CREATE PROCEDURE procedure_name() +BEGIN + DECLARE ABC INTERVAL ; +END; +CREATE PROCEDURE procedure_name(param_a int32, OUT param_b string, INOUT param_c ANY TYPE) +WITH CONNECTION DEFAULT OPTIONS + (a = b, c = d) +LANGUAGE PYTHON AS "python code"; +CREATE PROCEDURE procedure_name(param_a int32, OUT param_b string, INOUT param_c ANY TYPE) +WITH CONNECTION connection_id OPTIONS + (a = b, c = d) +LANGUAGE PYTHON AS "python code"; +CREATE PROCEDURE procedure_name(param_a int32, OUT param_b string, INOUT param_c ANY TYPE) +WITH CONNECTION connection_id OPTIONS + () +LANGUAGE PYTHON AS "python code"; +CREATE PROCEDURE procedure_name(param_a int32, OUT param_b string, INOUT param_c ANY TYPE) +OPTIONS + (a = b, c = d) +LANGUAGE PYTHON AS "python code"; +CREATE PROCEDURE procedure_name(param_a int32, OUT param_b string, INOUT param_c ANY TYPE) +OPTIONS + (a = b, c = d) +LANGUAGE PYTHON; +CREATE PROCEDURE procedure_name() +EXTERNAL SECURITY INVOKER LANGUAGE PYTHON; diff --git a/googlesql/examples/zetasql/parser/testdata/create_row_access_policy.sql b/googlesql/examples/zetasql/parser/testdata/create_row_access_policy.sql new file mode 100644 index 0000000..12b45f7 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/create_row_access_policy.sql @@ -0,0 +1,7 @@ +CREATE ROW ACCESS POLICY ON t1 GRANT TO ('foo@google.com') FILTER USING (c1 = 'foo'); +CREATE ROW ACCESS POLICY p1 ON t1 GRANT TO ('mdbuser/bar') FILTER USING (c2 = 'foo'); +CREATE ROW ACCESS POLICY ON t1 GRANT TO ('foo@google.com', 'mdbgroup/bar') FILTER USING (c1); +CREATE ROW ACCESS POLICY ON n1.t1 GRANT TO ('foo@google.com', 'mdbgroup/bar') FILTER USING (c1); +CREATE ROW ACCESS POLICY ON n1.t1 GRANT TO ('foo@google.com', 'mdbgroup/bar') FILTER USING (1); +CREATE ROW ACCESS POLICY ON t1 GRANT TO (@test_param_string) FILTER USING (true); +CREATE ROW ACCESS POLICY p1 ON t1 FILTER USING (true); diff --git a/googlesql/examples/zetasql/parser/testdata/create_schema.sql b/googlesql/examples/zetasql/parser/testdata/create_schema.sql new file mode 100644 index 0000000..288997d --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/create_schema.sql @@ -0,0 +1,13 @@ +CREATE SCHEMA foo; +CREATE OR REPLACE SCHEMA IF NOT EXISTS foo.bar +OPTIONS(); +CREATE SCHEMA foo +OPTIONS(x = 'a', y = 'b'); +CREATE OR REPLACE SCHEMA IF NOT EXISTS foo.bar DEFAULT COLLATE 'unicode:ci' +OPTIONS(); +CREATE SCHEMA foo DEFAULT COLLATE 'unicode:ci' +OPTIONS(x = 'a', y = 'b'); +CREATE SCHEMA foo DEFAULT COLLATE @@a +OPTIONS(x = 'a', y = 'b'); +CREATE SCHEMA foo DEFAULT COLLATE ? +OPTIONS(x = 'a', y = 'b'); diff --git a/googlesql/examples/zetasql/parser/testdata/create_table_as_select.sql b/googlesql/examples/zetasql/parser/testdata/create_table_as_select.sql new file mode 100644 index 0000000..5c84355 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/create_table_as_select.sql @@ -0,0 +1,222 @@ +CREATE TABLE t1 AS +SELECT + * +FROM + t2; +CREATE TABLE t1 LIKE +t2 AS +SELECT + * +FROM + t2; +CREATE TABLE t1 +( + x int64 +) LIKE +t2 AS +SELECT + * +FROM + t2; +CREATE PRIVATE TABLE pkg1.pkg2.`t 2` AS +SELECT + 1 AS a; +CREATE TEMP TABLE pkg1.pkg2.`t 2` AS +SELECT + 1 +FROM + t2 +UNION ALL +SELECT + 2 +FROM + t3 + CROSS JOIN + t4; +CREATE TABLE t3 AS +WITH + tt AS ( + SELECT + * + FROM + KeyValue + ) +SELECT + * +FROM + tt; +CREATE TABLE t4 OPTIONS(x = y) AS +WITH + t1 AS ( + SELECT + 1 + ), + t2 AS ( + SELECT + 2 + ) +SELECT + 3; +CREATE TABLE tt OPTIONS(x = 1) AS +SELECT + 1; +CREATE TEMP TABLE tt OPTIONS(x = 5, y = 'abc', z = @param, zz = ident, zzz = @@sysvar) AS +SELECT + 2; +CREATE TABLE tt OPTIONS() AS +SELECT + 2; +CREATE TABLE tt OPTIONS(x = 5.5, y = a, z = b.c) AS +SELECT + 2; +CREATE TABLE tt OPTIONS(y = 'b.c', z = `b.c`) AS +SELECT + 2; +CREATE TABLE options AS +SELECT + 1 AS x; +CREATE TABLE options OPTIONS(x = y) AS +SELECT + 1 AS x; +CREATE TABLE options OPTIONS(x = y) AS +SELECT + 1 AS x; +CREATE OR REPLACE TABLE xyz AS +( +SELECT + 1 +); +CREATE TABLE IF NOT EXISTS xyz AS +( +SELECT + 1 +); +CREATE OR REPLACE TEMP TABLE IF NOT EXISTS a.b.c OPTIONS(d = e) AS +SELECT + 1; +CREATE TABLE t AS +WITH + q AS ( + SELECT + 1 + ), + q2 AS ( + SELECT + * + FROM + q + ) +SELECT + * +FROM + q2; +CREATE TABLE t1 +( + a int64, + b string +) AS +SELECT + 1 AS a, + 'hi' AS b; +CREATE TEMP TABLE t +( + param1 int64, + param2 int64 +) AS +SELECT + 1, + 2, + 3; +CREATE TABLE `function` AS +SELECT + 1, + 2, + 3; +CREATE TABLE t1 PARTITION BY key, value AS +SELECT + key, + value +FROM + KeyValue; +CREATE TABLE t1 +( + a int64, + b string +) PARTITION BY b AS +SELECT + 1 AS a, + 'hi' AS b; +CREATE TABLE t1 CLUSTER BY key, value AS +SELECT + key, + value +FROM + KeyValue; +CREATE TABLE t1 +( + a int64, + b string +) CLUSTER BY b AS +SELECT + 1 AS a, + 'hi' AS b; +CREATE TABLE t1 +( + a int64, + b string +) PARTITION BY b CLUSTER BY a OPTIONS(key = 'value') AS +SELECT + 1 AS a, + 'hi' AS b; +CREATE TABLE t1 AS +SELECT + 1 AS a, + 2 AS b; +CREATE TABLE t1 +( + a int64, + b string +) AS +SELECT + 1 AS a, + 'foo' AS b; +CREATE TABLE t1 +( + a int64, + b string +) WITH CONNECTION DEFAULT AS +SELECT + 1 AS a, + 'foo' AS b; +CREATE TABLE t1 +( + a int64, + b string +) WITH CONNECTION connection1 AS +SELECT + 1 AS a, + 'foo' AS b; +CREATE TABLE t1 +( + a int64, + b string +) WITH CONNECTION connection1 OPTIONS(foo = x, bar = b) AS +SELECT + 1 AS a, + 'foo' AS b; +CREATE TABLE t1 +( + a int64, + b string +) WITH CONNECTION us.connection1 OPTIONS(foo = x, bar = b) AS +SELECT + 1 AS a, + 'foo' AS b; +CREATE TABLE t1 +( + a int64, + b string +) WITH CONNECTION myproject.us.connection1 OPTIONS(foo = x, bar = b) AS +SELECT + 1 AS a, + 'foo' AS b; diff --git a/googlesql/examples/zetasql/parser/testdata/create_view.sql b/googlesql/examples/zetasql/parser/testdata/create_view.sql new file mode 100644 index 0000000..3bed3a0 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/create_view.sql @@ -0,0 +1,116 @@ +CREATE APPROX VIEW t1 AS +SELECT + * +FROM + t2; +CREATE PRIVATE VIEW pkg1.pkg2.`t 2` AS +SELECT + 1 AS a; +CREATE TEMP VIEW pkg1.pkg2.`t 2` AS +SELECT + 1 +FROM + t2 +UNION ALL +SELECT + 2 +FROM + t3 + CROSS JOIN + t4; +CREATE VIEW t3 AS +WITH + tt AS ( + SELECT + * + FROM + KeyValue + ) +SELECT + * +FROM + tt; +CREATE VIEW t4 OPTIONS(x = y) AS +WITH + t1 AS ( + SELECT + 1 + ), + t2 AS ( + SELECT + 2 + ) +SELECT + 3; +CREATE VIEW tt OPTIONS(x = 1) AS +SELECT + 1; +CREATE VIEW tt OPTIONS() AS +SELECT + 2; +CREATE VIEW tt OPTIONS(x = 5.5, y = a, z = b.c) AS +SELECT + 2; +CREATE VIEW tt OPTIONS(y = 'b.c', z = `b.c`) AS +SELECT + 2; +CREATE VIEW options AS +SELECT + 1 AS x; +CREATE VIEW options OPTIONS(x = y) AS +SELECT + 1 AS x; +CREATE VIEW options OPTIONS(x = y) AS +SELECT + 1 AS x; +CREATE OR REPLACE APPROX VIEW xyz AS +( +SELECT + 1 +); +CREATE VIEW IF NOT EXISTS xyz AS +( +SELECT + 1 +); +CREATE OR REPLACE TEMP VIEW IF NOT EXISTS a.b.c OPTIONS(d = e) AS +SELECT + 1; +CREATE VIEW t AS +WITH + q AS ( + SELECT + 1 + ), + q2 AS ( + SELECT + * + FROM + q + ) +SELECT + * +FROM + q2; +CREATE APPROX VIEW v(a1, b2) AS +SELECT + 1 AS a, + 2 AS b; +CREATE APPROX VIEW v(a1 OPTIONS(description = "test view"), b2) AS +SELECT + 1 AS a, + 2 AS b; +CREATE APPROX VIEW v(a1 OPTIONS(description = "test view"), b2 OPTIONS()) AS +SELECT + 1 AS a, + 2 AS b; +CREATE APPROX RECURSIVE VIEW t1 AS +SELECT + * +FROM + t1; +CREATE PRIVATE RECURSIVE VIEW t1 AS +SELECT + * +FROM + t1; diff --git a/googlesql/examples/zetasql/parser/testdata/define_table.sql b/googlesql/examples/zetasql/parser/testdata/define_table.sql new file mode 100644 index 0000000..ebd620a --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/define_table.sql @@ -0,0 +1,10 @@ +DEFINE TABLE t1(a = 1, b = "a", c = 1.4, d = true); +DEFINE TABLE a.b.`c 2`(x = ''' +foo''', y = "2011-10-22", z = @param, zz = @@sysvar); +DEFINE TABLE t1(a = b); +DEFINE TABLE t1(); +DEFINE TABLE t1(a = b + 1); +DEFINE TABLE t1(x = y.z); +DEFINE TABLE x.`all`(a = 1); +DEFINE TABLE t1(a = CAST(1 AS INT32)); +DEFINE TABLE t1(`PROTO` = "PROTO", `hash` = "HASH"); diff --git a/googlesql/examples/zetasql/parser/testdata/describe.sql b/googlesql/examples/zetasql/parser/testdata/describe.sql new file mode 100644 index 0000000..7df366f --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/describe.sql @@ -0,0 +1,13 @@ +DESCRIBE foo; +DESCRIBE namespace.foo; +DESCRIBE INDEX myindex; +DESCRIBE INDEX mynamespace.myindex; +DESCRIBE `FUNCTION` myfunction; +DESCRIBE `FUNCTION` mynamespace.myfunction; +DESCRIBE TVF mytvf; +DESCRIBE TVF mynamespace.mytvf; +DESCRIBE TYPE mytype; +DESCRIBE TYPE mynamespace.mytype; +DESCRIBE foo FROM namespace; +DESCRIBE COLUMN foo FROM T.suffix; +DESCRIBE TYPE prefixed.name FROM Catalog.`With`.Dots; diff --git a/googlesql/examples/zetasql/parser/testdata/dml_delete.sql b/googlesql/examples/zetasql/parser/testdata/dml_delete.sql new file mode 100644 index 0000000..bef8dc7 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/dml_delete.sql @@ -0,0 +1,35 @@ +DELETE T; +DELETE x.T +WHERE + true; +DELETE T WITH OFFSET AS offset +WHERE + true; +DELETE a.b.c +WHERE + c = y +ASSERT_ROWS_MODIFIED 10; +DELETE T +ASSERT_ROWS_MODIFIED CAST(@param1 AS int64); +DELETE T +ASSERT_ROWS_MODIFIED CAST(@@sysvar AS int64); +DELETE T +WHERE + 1 + ( + SELECT + count(*) + FROM + T2 + ) = 5 +ASSERT_ROWS_MODIFIED @row_count; +DELETE T.(a.b).c +WHERE + true; +DELETE T.a[0].b +WHERE + true; +DELETE T AS a +WHERE + a.x = 1; +@{ a = b } +DELETE t1; diff --git a/googlesql/examples/zetasql/parser/testdata/dml_insert.sql b/googlesql/examples/zetasql/parser/testdata/dml_insert.sql new file mode 100644 index 0000000..b20b87a --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/dml_insert.sql @@ -0,0 +1,114 @@ +INSERT INTO T +VALUES + (1); +INSERT OR IGNORE INTO values +VALUES + (5, 6), + ('abc') +ASSERT_ROWS_MODIFIED 5; +INSERT INTO values +VALUES + (a, b); +INSERT INTO mytable +VALUES + (a, b); +INSERT INTO values(a, `default`) +VALUES + (1, 3); +INSERT OR IGNORE INTO `replace` +SELECT + 1; +INSERT INTO insert +SELECT + 1; +INSERT INTO `replace` +SELECT + 1; +INSERT INTO T(c1) +WITH + q1 AS ( + SELECT + 1 + ) +SELECT + * +FROM + q1 +ASSERT_ROWS_MODIFIED @row_count; +INSERT INTO T +VALUES + ((1, 2), ( + SELECT + 1 + )); +INSERT INTO T +VALUES + (1, 2), + (( + SELECT + 1 + )); +INSERT INTO T +WITH + q1 AS ( + SELECT + 1 + ) +SELECT + * +FROM + q1; +INSERT OR REPLACE INTO T +SELECT + * +FROM + q1 +UNION ALL +SELECT + * +FROM + q2 +ORDER BY x +LIMIT 5 +ASSERT_ROWS_MODIFIED 0; +INSERT INTO T(c1, c2) +VALUES + (1 + 2, f(), null, DEFAULT), + (DEFAULT, ( + SELECT + x + FROM + y + )); +INSERT INTO T +( +SELECT + 5 +); +INSERT INTO T +(( +SELECT + 1 +) UNION ALL( +SELECT + 2 +)); +INSERT INTO T(c1, c2) +( +SELECT + 5, + 7 +) UNION ALL +SELECT + 8, + 9; +INSERT INTO T.(a.b).c +VALUES + (1); +INSERT INTO T.a[0].b +VALUES + (1); +@{ a = b } +INSERT INTO t1 +VALUES + (null); diff --git a/googlesql/examples/zetasql/parser/testdata/dml_insert_on_conflict_clause.sql b/googlesql/examples/zetasql/parser/testdata/dml_insert_on_conflict_clause.sql new file mode 100644 index 0000000..21baf06 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/dml_insert_on_conflict_clause.sql @@ -0,0 +1,124 @@ +INSERT OR IGNORE INTO T(a, b) +VALUES + (1, 2) +ON CONFLICT DO NOTHING; +INSERT INTO T(a, b) +VALUES + (1, 2) +ON CONFLICT DO NOTHING; +INSERT INTO T(a, b) +VALUES + (1, 2) +ON CONFLICT DO UPDATE +SET a = a + excluded.a; +INSERT INTO T(a, b) +VALUES + (1, 2) +ON CONFLICT DO UPDATE +SET a = a + excluded.a +WHERE b > 10; +INSERT INTO T(a, b) +VALUES + (1, 2) +ON CONFLICT(a) DO NOTHING; +INSERT INTO T(a, b) +VALUES + (1, 2) +ON CONFLICT(a, b) DO NOTHING; +INSERT INTO T(a, b) +VALUES + (1, 2) +ON CONFLICT ON UNIQUE CONSTRAINT index DO NOTHING; +INSERT INTO T(a, b) +VALUES + (1, 2) +ON CONFLICT ON UNIQUE CONSTRAINT index DO UPDATE +SET a = a + excluded.a; +INSERT INTO T(a, b) +VALUES + (1, 2) +ON CONFLICT(a) DO NOTHING +THEN RETURN WITH ACTION AS myaction + a, + b; +INSERT INTO T(a, b) +VALUES + (1, 2) +ON CONFLICT(a) DO NOTHING +ASSERT_ROWS_MODIFIED 1; +INSERT INTO T(a, b) +VALUES + (1, 2) +ON CONFLICT DO NOTHING +ASSERT_ROWS_MODIFIED 1 +THEN RETURN WITH ACTION AS ACTION + a, + b; +INSERT INTO T(a, b) +VALUES + (1, 2) +ON CONFLICT(a) DO UPDATE +SET a = a + excluded.a +WHERE b < 10 +ASSERT_ROWS_MODIFIED 5 +THEN RETURN WITH ACTION AS ACTION + a, + b; +INSERT INTO T(a, b) +VALUES + (1, 2) +ON CONFLICT(a) DO UPDATE +SET a = a + excluded.a +WHERE b < 10 +ASSERT_ROWS_MODIFIED 5; +INSERT INTO T(a, b) +VALUES + (1, 2) +ON CONFLICT(a) DO UPDATE +SET a = a + excluded.a +WHERE b < 10 +THEN RETURN + a, + excluded.a; +INSERT INTO T(a, b) +( +SELECT + a, + b +FROM + otherT +) +ON CONFLICT DO NOTHING; +INSERT INTO T(a, b) +( +SELECT + a, + b +FROM + otherT + JOIN + T + ON T.a = otherT.a +) +ON CONFLICT(a) DO UPDATE +SET a = a + excluded.a +WHERE b < 10; +INSERT INTO T(a, b) +VALUES + (1, 2) +ON CONFLICT ON UNIQUE CONSTRAINT index DO NOTHING +THEN RETURN + a; +INSERT INTO T(a, b) +( +SELECT + a, + b +FROM + otherT + JOIN + T + ON conflict = conflict2 +) +ON CONFLICT(a) DO UPDATE +SET a = a + excluded.a; diff --git a/googlesql/examples/zetasql/parser/testdata/dml_merge.sql b/googlesql/examples/zetasql/parser/testdata/dml_merge.sql new file mode 100644 index 0000000..f3af2b7 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/dml_merge.sql @@ -0,0 +1,186 @@ +MERGE INTO T +USING S +ON t1 = s1 +WHEN MATCHED AND T.T1 = 5 THEN + UPDATE + SET + T1 = T1 + 10, + T2 = T.T1 + S.C1; +MERGE INTO T +USING S +ON t1 = s1 +WHEN MATCHED AND T.T1 = 5 THEN + UPDATE + SET + T1.(foo.bar) = T1.(foo.bar) + 10, + T2 = T.T1 + S.C1; +MERGE INTO T +USING S +ON t1 = s1 +WHEN NOT MATCHED BY TARGET THEN + INSERT(t1, t2, t3) + VALUES + (10, S.C3, S.C1 + S.C2); +MERGE INTO T +USING S +ON t1 = s1 +WHEN NOT MATCHED BY SOURCE THEN + DELETE; +MERGE INTO T +USING S +ON t1 = s1 +WHEN MATCHED AND T.T1 = 5 THEN + UPDATE + SET + T1 = T1 + 10, + T2 = T.T1 + S.C1 +WHEN NOT MATCHED BY TARGET THEN + INSERT(t1, t2, t3) + VALUES + (10, S.C3, S.C1 + S.C2); +MERGE INTO T +USING S +ON t1 = s1 +WHEN MATCHED AND T.T1 = 5 THEN + UPDATE + SET + T1 = T1 + 10, + T2 = T.T1 + S.C1 +WHEN NOT MATCHED BY SOURCE THEN + DELETE; +MERGE INTO T +USING S +ON t1 = s1 +WHEN NOT MATCHED BY TARGET THEN + INSERT(t1, t2, t3) + VALUES + (10, S.C3, S.C1 + S.C2) +WHEN NOT MATCHED BY SOURCE THEN + DELETE; +MERGE INTO T +USING S +ON t1 = s1 +WHEN MATCHED AND T.T1 = 5 THEN + UPDATE + SET + T1 = T1 + 10, + T2 = T.T1 + S.C1 +WHEN NOT MATCHED BY TARGET THEN + INSERT(t1, t2, t3) + VALUES + (10, S.C3, S.C1 + S.C2) +WHEN NOT MATCHED BY SOURCE THEN + DELETE; +MERGE INTO T +USING S +ON T.t1 = S.s1 +WHEN NOT MATCHED BY TARGET AND s1 > 10 THEN + INSERT(t1) + VALUES + (10); +MERGE INTO T +USING S +ON T.t1 = S.s1 +WHEN NOT MATCHED BY TARGET THEN + INSERT(t1) + VALUES + (10); +MERGE INTO T +USING +( + SELECT + * + FROM + Y + JOIN + Z + ON Y.C1 = Z.C1 +) AS S +ON t1 = s1 +WHEN NOT MATCHED BY TARGET AND S.C2 = 20 THEN + INSERT(t1, t2, t3) + VALUES + (10, S.C3, S.C1 + S.C2); +MERGE INTO T AS X +USING S +ON X.t1 = S.s1 +WHEN NOT MATCHED BY TARGET AND S.C1 > 100 THEN + INSERT(t1) + VALUES + (S.C2) +WHEN NOT MATCHED BY TARGET AND S.C1 > 50 THEN + INSERT(t1) + VALUES + (S.C2 * 10) +WHEN NOT MATCHED BY TARGET THEN + INSERT(t1) + VALUES + (S.C2 * 100); +MERGE INTO T +USING +( + SELECT + * + FROM + Y + JOIN + Z + ON Y.C1 = Z.C1 +) AS S +ON t1 = s1 +WHEN MATCHED AND T.T1 = 5 AND S.C3 < 0 THEN + UPDATE + SET + T1 = T1 + 10, + T2 = T.T1 + S.C1 +WHEN MATCHED THEN + DELETE +WHEN NOT MATCHED BY TARGET AND S.C2 = 20 THEN + INSERT(t1, t2, t3) + VALUES + (10, S.C3, S.C1 + S.C2); +MERGE INTO T +USING S +ON t1 = s1 +WHEN MATCHED THEN + INSERT(t1) + VALUES + (10); +MERGE INTO T +USING S +ON t1 = s1 +WHEN NOT MATCHED BY TARGET THEN + DELETE; +MERGE INTO T +USING S +ON t1 = s1 +WHEN NOT MATCHED BY TARGET THEN + UPDATE + SET + t1 = 10; +MERGE INTO T +USING S +ON t1 = s1 +WHEN NOT MATCHED BY SOURCE THEN + INSERT(t1) + VALUES + (s2); +MERGE INTO T +USING S +ON t1 = s1 +WHEN NOT MATCHED BY SOURCE THEN + INSERT + VALUES + (s2); +MERGE INTO T +USING S +ON t1 = s1 +WHEN NOT MATCHED BY SOURCE THEN + INSERT(t1) + ROW; +MERGE INTO T +USING S +ON t1 = s1 +WHEN NOT MATCHED BY SOURCE THEN + INSERT + ROW; diff --git a/googlesql/examples/zetasql/parser/testdata/dml_update.sql b/googlesql/examples/zetasql/parser/testdata/dml_update.sql new file mode 100644 index 0000000..d67290a --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/dml_update.sql @@ -0,0 +1,202 @@ +UPDATE T +SET + x = y; +UPDATE T WITH OFFSET AS offset +SET + x = y; +UPDATE T.(a.b).c +SET + x = y; +UPDATE T.a[0].b +SET + x = y; +UPDATE T +SET + id.(path.`to`.extension) = 5; +UPDATE T +SET + id.(path.`to`.extension) = DEFAULT; +UPDATE T +SET + id[0] = DEFAULT; +UPDATE T +SET + id1.id2.(path.`to`.extension) = 5; +UPDATE T +SET + id1.(id2).(id3) = 5; +UPDATE T +SET + id1.(a.b.c).(d.e.f).id2.(g.h.i).id3.id4 = 5; +UPDATE T +SET + id1[0] = 5; +UPDATE T +SET + id1[0].(a.b.c).id1.(d.e.f)[1].id3 = 5; +UPDATE T +SET + id1[0][1] = 5; +UPDATE c.T +SET + x = y, + a.b.c = 1 + ( + SELECT + count(*) + FROM + t2 + ) +WHERE + zzz + yyy = 55 +ASSERT_ROWS_MODIFIED @row_count; +UPDATE T +SET + x = null, + y = DEFAULT, + z = z; +UPDATE T AS a +SET + a.x = 1; +UPDATE T +SET + x = y, + ( + DELETE x + ), + ( + INSERT INTO y.z + VALUES + (5) + ), + ( + UPDATE a + SET + b = c + ), + z = DEFAULT; +UPDATE T +SET + ( + DELETE a.(b.c) + ), + ( + INSERT INTO d.(e.f) + VALUES + (5) + ), + ( + UPDATE a.(b.c) + SET + d = 10 + ); +UPDATE T +SET + ( + DELETE a.(b.c).x + ), + ( + INSERT INTO d.(e.f).y + VALUES + (5) + ), + ( + UPDATE a.(b.c).x + SET + d = 10 + ); +UPDATE T +SET + ( + DELETE a.(b.c)[0].d + ), + ( + INSERT INTO d.(e.f)[1] + VALUES + (5) + ), + ( + UPDATE a[2].(b.c) + SET + d = 10 + ); +UPDATE T AS a +SET + a.x = y, + ( + DELETE a.x AS na + WHERE + na.x = 1 + ), + ( + UPDATE a.x AS na + SET + na.x = 1 + ), + ( + INSERT INTO a.x + VALUES + (5) + ); +UPDATE T +SET + ( + UPDATE c1.c2 + SET + ( + UPDATE c3 + SET + ( + DELETE c4 + WHERE + false + ASSERT_ROWS_MODIFIED 5 + ) + WHERE + true + ASSERT_ROWS_MODIFIED 4 + ) + WHERE + false + ASSERT_ROWS_MODIFIED 3 + ) +WHERE + true +ASSERT_ROWS_MODIFIED 2; +UPDATE T +SET + x = T1.y +FROM + T1 +WHERE + T.a = T1.b; +UPDATE T +SET + x = T2.c +FROM + T1 + JOIN + T2 + ON T1.x = T2.y +WHERE + T.a < T1.b; +UPDATE T +SET + x = T2.c +FROM + T1, + T2 +WHERE + T.a < T1.b; +UPDATE T +SET + x = 1 +FROM + ( + T1 + JOIN + T2 + ) + JOIN + T3 +WHERE + true; diff --git a/googlesql/examples/zetasql/parser/testdata/drop.sql b/googlesql/examples/zetasql/parser/testdata/drop.sql new file mode 100644 index 0000000..e18e779 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/drop.sql @@ -0,0 +1,12 @@ +DROP EXTERNAL TABLE `function`; +DROP TABLE bar; +DROP TABLE IF EXISTS bar; +DROP TABLE bar.baz; +DROP TABLE IF EXISTS bar.baz; +DROP MATERIALIZED VIEW a; +DROP MATERIALIZED VIEW IF EXISTS a; +DROP MATERIALIZED VIEW IF EXISTS a.b; +DROP SNAPSHOT TABLE a; +DROP SNAPSHOT TABLE IF EXISTS a; +DROP SNAPSHOT TABLE IF EXISTS `snapshot-1`; +DROP CONNECTION IF EXISTS foo; diff --git a/googlesql/examples/zetasql/parser/testdata/drop_function.sql b/googlesql/examples/zetasql/parser/testdata/drop_function.sql new file mode 100644 index 0000000..b8aae3f --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/drop_function.sql @@ -0,0 +1,21 @@ +DROP FUNCTION foo; +DROP FUNCTION IF EXISTS foo; +DROP FUNCTION foo(); +DROP FUNCTION foo.bar; +DROP FUNCTION foo.bar(); +DROP FUNCTION IF EXISTS foo(); +DROP FUNCTION foo.bar(int32); +DROP FUNCTION foo.bar(a int32); +DROP FUNCTION foo.bar(int32, STRUCT< a string, b boolean >); +DROP FUNCTION foo.bar(int32, str STRUCT< a string, b boolean >); +DROP FUNCTION foo.bar(a int32, the_struct STRUCT< a string, b boolean >); +DROP FUNCTION myfunc(string NOT AGGREGATE, s string, int32, i int32 NOT AGGREGATE); +DROP FUNCTION foo.bar(int32 AS x); +DROP FUNCTION foo.bar(int32 x); +DROP FUNCTION foo.bar(a int32 AS x); +DROP FUNCTION foo.bar(a int32 AS x NOT AGGREGATE); +DROP TABLE FUNCTION foo; +DROP TABLE FUNCTION IF EXISTS foo; +DROP TABLE FUNCTION foo.bar; +DROP FUNCTION foo.bar(string, TABLE< int32, bool >); +DROP FUNCTION foo.bar(a string, b TABLE< x int32, y bool >); diff --git a/googlesql/examples/zetasql/parser/testdata/drop_row_access_policy.sql b/googlesql/examples/zetasql/parser/testdata/drop_row_access_policy.sql new file mode 100644 index 0000000..81dbf42 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/drop_row_access_policy.sql @@ -0,0 +1,7 @@ +DROP ROW ACCESS POLICY foo ON t1; +DROP ROW ACCESS POLICY `all` ON t1; +DROP ROW ACCESS POLICY foo ON namespace.`all`.t1; +DROP ROW ACCESS POLICY IF EXISTS foo ON t1; +DROP ROW ACCESS POLICY IF EXISTS foo ON namespace.`all`.t1; +DROP ROW ACCESS POLICY `if exists foo` ON t1; +DROP ALL ROW POLICIES ON t1; diff --git a/googlesql/examples/zetasql/parser/testdata/execute_immediate.sql b/googlesql/examples/zetasql/parser/testdata/execute_immediate.sql new file mode 100644 index 0000000..2128928 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/execute_immediate.sql @@ -0,0 +1,9 @@ +EXECUTE IMMEDIATE @@x; +EXECUTE IMMEDIATE "? ?" USING 0, 1; +EXECUTE IMMEDIATE x USING @@t AS y; +EXECUTE IMMEDIATE x INTO a, b USING 4 AS y, 5 AS z; +SELECT + EXECUTE +FROM + IMMEDIATE; +EXECUTE IMMEDIATE "select ?, @x" USING 0, 5 AS x; diff --git a/googlesql/examples/zetasql/parser/testdata/export_data.sql b/googlesql/examples/zetasql/parser/testdata/export_data.sql new file mode 100644 index 0000000..afe388f --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/export_data.sql @@ -0,0 +1,42 @@ +EXPORT DATA AS +SELECT + 1; +EXPORT DATA OPTIONS() AS +SELECT + 1; +EXPORT DATA WITH CONNECTION DEFAULT OPTIONS(x = 5) AS +SELECT + 1; +EXPORT DATA WITH CONNECTION connection_id OPTIONS(x = 5) AS +SELECT + 1; +EXPORT DATA WITH CONNECTION connection OPTIONS(x = 5) AS +SELECT + 1; +EXPORT DATA WITH CONNECTION a.b.c OPTIONS(x = 5) AS +SELECT + 1; +EXPORT DATA OPTIONS(x = 5) AS +SELECT + 1; +EXPORT DATA OPTIONS(a = b, c = 'd') AS +( +SELECT + 1 +); +EXPORT DATA OPTIONS(a = b, c = d) AS +WITH + q AS ( + SELECT + 1 + ), + q2 AS ( + SELECT + * + FROM + q + ) +SELECT + * +FROM + q2; diff --git a/googlesql/examples/zetasql/parser/testdata/export_model.sql b/googlesql/examples/zetasql/parser/testdata/export_model.sql new file mode 100644 index 0000000..3a4853a --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/export_model.sql @@ -0,0 +1,4 @@ +EXPORT MODEL model.name WITH CONNECTION DEFAULT OPTIONS(uri = "destination"); +EXPORT MODEL model.name WITH CONNECTION connection_id OPTIONS(uri = "destination"); +EXPORT MODEL model.name OPTIONS(uri = "destination"); +EXPORT MODEL model.name WITH CONNECTION connection_id; diff --git a/googlesql/examples/zetasql/parser/testdata/grant_and_revoke.sql b/googlesql/examples/zetasql/parser/testdata/grant_and_revoke.sql new file mode 100644 index 0000000..6b6f7a8 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/grant_and_revoke.sql @@ -0,0 +1,11 @@ +GRANT `select`, `update` ON table foo TO 'user@google.com'; +GRANT ALL PRIVILEGES ON view foo TO @user1, @@user2, 'mdbuser/bar1', 'mdbuser/bar2'; +GRANT `select` ON materialized view foo TO 'user@google.com'; +REVOKE `select` ON materialized view foo FROM 'user@google.com'; +GRANT ALL PRIVILEGES ON datascape.foo TO 'bar'; +GRANT `select`, insert(col1, col2, col3), `update`(col2) ON foo TO 'mdbgroup/bar'; +GRANT execute ON script datascape.script_foo TO 'group@google.com'; +REVOKE ALL PRIVILEGES ON foo FROM 'bar'; +REVOKE delete ON table foo FROM 'mdbuser/bar'; +REVOKE ALL PRIVILEGES ON table table FROM 'mdbuser/user', @user2, 'user3', @@user4; +REVOKE delete, `update`(col2) ON view foo FROM 'mdbgroup/bar'; diff --git a/googlesql/examples/zetasql/parser/testdata/modules.sql b/googlesql/examples/zetasql/parser/testdata/modules.sql new file mode 100644 index 0000000..8d92ce4 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/modules.sql @@ -0,0 +1,25 @@ +IMPORT MODULE foo; +IMPORT MODULE foo.bar; +IMPORT MODULE foo.bar.baz; +IMPORT MODULE foo.bar AS alias; +IMPORT MODULE foo.bar AS `bar.baz`; +IMPORT MODULE foo OPTIONS(a = 1); +IMPORT MODULE a.foo AS foo OPTIONS(a = 1); +IMPORT MODULE module; +IMPORT MODULE module.`all`; +IMPORT MODULE foo AS TABLE; +IMPORT MODULE foo AS string; +IMPORT MODULE foo AS INT64; +MODULE foo; +MODULE foo.bar.baz; +MODULE foo.bar OPTIONS(a = 1); +MODULE foo.bar OPTIONS(a = 1, b = 'b', c = 3.0); +MODULE import; +MODULE module; +MODULE options; +MODULE import.module.options OPTIONS(a = 1); +MODULE module.`all`; +MODULE `all`; +MODULE module.`all`; +IMPORT MODULE "file.proto"; +IMPORT MODULE name.path INTO a; diff --git a/googlesql/examples/zetasql/parser/testdata/rename.sql b/googlesql/examples/zetasql/parser/testdata/rename.sql new file mode 100644 index 0000000..286afd2 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/rename.sql @@ -0,0 +1 @@ +RENAME foo bar TO baz; diff --git a/googlesql/examples/zetasql/parser/testdata/show.sql b/googlesql/examples/zetasql/parser/testdata/show.sql new file mode 100644 index 0000000..8fea20f --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/show.sql @@ -0,0 +1,14 @@ +SHOW TABLES; +SHOW TABLES FROM adwords; +SHOW TABLES FROM catalog.adwords; +SHOW TABLES LIKE 'KitchenSync%'; +SHOW COLUMNS FROM KitchenSync; +SHOW INDEXES FROM myschema.MyTable; +SHOW STATUS; +SHOW VARIABLES LIKE 'server_name'; +SHOW TABLES FROM catalog.adwords LIKE 'KitchenSync%'; +SHOW `MATERIALIZED VIEWS`; +SHOW `MATERIALIZED VIEWS`; +SHOW `MATERIALIZED VIEWS` LIKE 'KitchenSync%'; +SHOW `MATERIALIZED VIEWS` FROM KitchenSync; +SHOW `MATERIALIZED VIEWS` FROM KitchenSync LIKE '%foo%'; diff --git a/googlesql/examples/zetasql/parser/testdata/transaction.sql b/googlesql/examples/zetasql/parser/testdata/transaction.sql new file mode 100644 index 0000000..2c35e04 --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/transaction.sql @@ -0,0 +1,15 @@ +BEGIN TRANSACTION; +BEGIN TRANSACTION; +BEGIN TRANSACTION; +BEGIN TRANSACTION READ ONLY; +BEGIN TRANSACTION ISOLATION LEVEL read uncommited; +BEGIN TRANSACTION READ WRITE, ISOLATION LEVEL READ COMMITED; +BEGIN TRANSACTION ISOLATION LEVEL READ repeatable; +BEGIN TRANSACTION ISOLATION LEVEL Serializable; +BEGIN TRANSACTION ISOLATION LEVEL FOO bar; +SET TRANSACTION READ ONLY; +SET TRANSACTION READ WRITE, ISOLATION LEVEL foo; +COMMIT; +COMMIT; +ROLLBACK; +ROLLBACK; diff --git a/googlesql/examples/zetasql/parser/testdata/truncate.sql b/googlesql/examples/zetasql/parser/testdata/truncate.sql new file mode 100644 index 0000000..7392aeb --- /dev/null +++ b/googlesql/examples/zetasql/parser/testdata/truncate.sql @@ -0,0 +1,12 @@ +TRUNCATE TABLE foo; +TRUNCATE TABLE foo +WHERE + bar > 3; +SELECT + truncate +FROM + foo; +SELECT + * +FROM + truncate; diff --git a/googlesql/googlesql_lexer.go b/googlesql/googlesql_lexer.go new file mode 100644 index 0000000..842d5bb --- /dev/null +++ b/googlesql/googlesql_lexer.go @@ -0,0 +1,2329 @@ +// Code generated from GoogleSQLLexer.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package googlesql + +import ( + "fmt" + "github.com/antlr4-go/antlr/v4" + "sync" + "unicode" +) + +// Suppress unused import error +var _ = fmt.Printf +var _ = sync.Once{} +var _ = unicode.IsLetter + +type GoogleSQLLexer struct { + *antlr.BaseLexer + channelNames []string + modeNames []string + // TODO: EOF string +} + +var GoogleSQLLexerLexerStaticData struct { + once sync.Once + serializedATN []int32 + ChannelNames []string + ModeNames []string + LiteralNames []string + SymbolicNames []string + RuleNames []string + PredictionContextCache *antlr.PredictionContextCache + atn *antlr.ATN + decisionToDFA []*antlr.DFA +} + +func googlesqllexerLexerInit() { + staticData := &GoogleSQLLexerLexerStaticData + staticData.ChannelNames = []string{ + "DEFAULT_TOKEN_CHANNEL", "HIDDEN", + } + staticData.ModeNames = []string{ + "DEFAULT_MODE", + } + staticData.LiteralNames = []string{ + "", "'='", "'!='", "'<>'", "'<'", "'<='", "'>'", "'>='", "'<<'", "'>>'", + "'+'", "'-'", "'*'", "'/'", "'~'", "'!'", "'%'", "','", "'.'", "'{'", + "'}'", "'('", "')'", "'['", "']'", "'|'", "':'", "';'", "'''", "'''''", + "'\"'", "'\"\"\"'", "'`'", "'?'", "'@'", "'@@'", "'=>'", "'->'", "'+='", + "'-='", "'|>'", "'^'", "'&'", "'||'", "", "", "", "", "", "", "", "", + "", "", "", "", "'ARRAY'", "'ALL'", "'AS'", "'ASC'", "'BY'", "'CROSS'", + "'JOIN'", "'DELTA'", "'DESC'", "'DIFFERENTIAL_PRIVACY'", "'DISTINCT'", + "'EPSILON'", "'EXCEPT'", "'EXCLUDE'", "'FOR'", "'FROM'", "'FULL'", "'IN'", + "'INCLUDE'", "'INNER'", "'INTERSECT'", "'LEFT'", "'LIMIT'", "'MAX_GROUPS_CONTRIBUTED'", + "'NULL'", "'NULLS'", "'OF'", "'OFFSET'", "'ON'", "'OPTIONS'", "'ORDER'", + "'OUTER'", "'PERCENT'", "'PIVOT'", "'PRIVACY_UNIT_COLUMN'", "'RIGHT'", + "'RECURSIVE'", "'REPLACE'", "'UNPIVOT'", "'SELECT'", "'STRUCT'", "'SYSTEM'", + "'SYSTEM_TIME'", "'TABLESAMPLE'", "'UNION'", "'UNNEST'", "'USING'", + "'VALUE'", "'WITH'", "'TRUE'", "'FALSE'", "'NUMERIC'", "'DECIMAL'", + "'BIGNUMERIC'", "'BIGDECIMAL'", "'NOT'", "'AND'", "'OR'", "'JSON'", + "'DATE'", "'TIME'", "'DATETIME'", "'TIMESTAMP'", "'RANGE'", "'INTERVAL'", + "'SIMPLE'", "'ABORT'", "'ACCESS'", "'ACTION'", "'AGGREGATE'", "'ADD'", + "'ALTER'", "'ALWAYS'", "'ANALYZE'", "'APPROX'", "'ARE'", "'ASSERT'", + "'BATCH'", "'BEGIN'", "'BREAK'", "'CALL'", "'CASCADE'", "'CHECK'", "'CLAMPED'", + "'CLONE'", "'COPY'", "'CLUSTER'", "'COLUMN'", "'COLUMNS'", "'COMMIT'", + "'CONNECTION'", "'CONSTANT'", "'CONSTRAINT'", "'CONTINUE'", "'CORRESPONDING'", + "'CYCLE'", "'DATA'", "'DATABASE'", "'DECLARE'", "'DEFINER'", "'DELETE'", + "'DELETION'", "'DEPTH'", "'DESCRIBE'", "'DETERMINISTIC'", "'DO'", "'DROP'", + "'ELSEIF'", "'ENFORCED'", "'ERROR'", "'EXCEPTION'", "'EXECUTE'", "'EXPLAIN'", + "'EXPORT'", "'EXTEND'", "'EXTERNAL'", "'FILES'", "'FILTER'", "'FILL'", + "'FIRST'", "'FOREIGN'", "'FORMAT'", "'FUNCTION'", "'GENERATED'", "'GRANT'", + "'GROUP_ROWS'", "'HIDDEN'", "'IDENTITY'", "'IMMEDIATE'", "'IMMUTABLE'", + "'IMPORT'", "'INCREMENT'", "'INDEX'", "'INOUT'", "'INPUT'", "'INSERT'", + "'INVOKER'", "'ISOLATION'", "'ITERATE'", "'KEY'", "'LANGUAGE'", "'LAST'", + "'LEAVE'", "'LEVEL'", "'LOAD'", "'LOOP'", "'MACRO'", "'MAP'", "'MATCH'", + "'KW_MATCH_RECOGNIZE_NONRESERVED'", "'MATCHED'", "'MATERIALIZED'", "'MAX'", + "'MAXVALUE'", "'MEASURES'", "'MESSAGE'", "'METADATA'", "'MIN'", "'MINVALUE'", + "'MODEL'", "'MODULE'", "'ONLY'", "'OUT'", "'OUTPUT'", "'OVERWRITE'", + "'PARTITIONS'", "'PATTERN'", "'POLICIES'", "'POLICY'", "'PRIMARY'", + "'PRIVATE'", "'PRIVILEGE'", "'PRIVILEGES'", "'PROCEDURE'", "'PROJECT'", + "'PUBLIC'", "'RAISE'", "'READ'", "'REFERENCES'", "'REMOTE'", "'REMOVE'", + "'RENAME'", "'REPEAT'", "'REPEATABLE'", "'REPLACE_FIELDS'", "'REPLICA'", + "'REPORT'", "'RESTRICT'", "'RESTRICTION'", "'RETURNS'", "'RETURN'", + "'REVOKE'", "'ROLLBACK'", "'ROW'", "'RUN'", "'SAFE_CAST'", "'SCHEMA'", + "'SEARCH'", "'SECURITY'", "'SEQUENCE'", "'SETS'", "'SET'", "'SHOW'", + "'SNAPSHOT'", "'SOURCE'", "'SQL'", "'STABLE'", "'START'", "'STATIC_DESCRIBE'", + "'STORED'", "'STORING'", "'STRICT'", "'TABLE'", "'TABLES'", "'TARGET'", + "'TEMP'", "'TEMPORARY'", "'TRANSACTION'", "'TRANSFORM'", "'TRUNCATE'", + "'TYPE'", "'UNDROP'", "'UNIQUE'", "'UNKNOWN'", "'UNTIL'", "'UPDATE'", + "'VALUES'", "'VECTOR'", "'VIEW'", "'VIEWS'", "'VOLATILE'", "'WEIGHT'", + "'WHILE'", "'WRITE'", "'ZONE'", "'DESCRIPTOR'", "'INTERLEAVE'", "'NULL_FILTERED'", + "'PARENT'", "'NEW'", "'END'", "'CASE'", "'WHEN'", "'THEN'", "'ELSE'", + "'CAST'", "'EXTRACT'", "'COLLATE'", "'IF'", "'GROUPING'", "'HAVING'", + "'GROUP'", "'ROLLUP'", "'CUBE'", "'HASH'", "'PROTO'", "'PARTITION'", + "'IGNORE'", "'RESPECT'", "'ROWS'", "'OVER'", "'BETWEEN'", "'UNBOUNDED'", + "'CURRENT'", "'PRECEDING'", "'FOLLOWING'", "'NATURAL'", "'QUALIFY'", + "'DEFAULT'", "'SLASH'", "'MATCH_RECOGNIZE'", "'DEFINE'", "'LOOKUP'", + "'WHERE'", "'WINDOW'", "'TO'", "'EXISTS'", "'ANY'", "'SOME'", "'LIKE'", + "'IS'", "'NO'", "'INTO'", "'ASSERT_ROWS_MODIFIED'", "'CONFLICT'", "'NOTHING'", + "'MERGE'", "'CREATE'", "'ENUM'", "'DESTINATION'", "'PROPERTY'", "'GRAPH'", + "'NODE'", "'PROPERTIES'", "'LABEL'", "'EDGE'", "'NEXT'", "'ASCENDING'", + "'DESCENDING'", "'SKIP'", "'SHORTEST'", "'PATH'", "'PATHS'", "'WALK'", + "'TRAIL'", "'ACYCLIC'", "'OPTIONAL'", "'LET'", + } + staticData.SymbolicNames = []string{ + "", "EQUAL_OPERATOR", "NOT_EQUAL_OPERATOR", "NOT_EQUAL2_OPERATOR", "LT_OPERATOR", + "LE_OPERATOR", "GT_OPERATOR", "GE_OPERATOR", "KL_OPERATOR", "KR_OPERATOR", + "PLUS_OPERATOR", "MINUS_OPERATOR", "MULTIPLY_OPERATOR", "DIVIDE_OPERATOR", + "BITWISE_NOT_OPERATOR", "EXCLAMATION_OPERATOR", "MODULO_OPERATOR", "COMMA_SYMBOL", + "DOT_SYMBOL", "LC_BRACKET_SYMBOL", "RC_BRACKET_SYMBOL", "LR_BRACKET_SYMBOL", + "RR_BRACKET_SYMBOL", "LS_BRACKET_SYMBOL", "RS_BRACKET_SYMBOL", "STROKE_SYMBOL", + "COLON_SYMBOL", "SEMI_SYMBOL", "SINGLE_QUOTE_SYMBOL", "SINGLE_QUOTE_3_SYMBOL", + "DOUBLE_QUOTE_SYMBOL", "DOUBLE_QUOTE_3_SYMBOL", "BACKQUOTE_SYMBOL", + "QUESTION_SYMBOL", "AT_SYMBOL", "ATAT_SYMBOL", "EQUAL_GT_BRACKET_SYMBOL", + "SUB_GT_BRACKET_SYMBOL", "PLUS_EQUAL_SYMBOL", "SUB_EQUAL_SYMBOL", "PIPE_SYMBOL", + "CIRCUMFLEX_SYMBOL", "BIT_AND_SYMBOL", "BOOL_OR_SYMBOL", "STRING_LITERAL", + "BYTES_LITERAL", "UNCLOSED_STRING_LITERAL", "UNCLOSED_TRIPLE_QUOTED_STRING_LITERAL", + "UNCLOSED_RAW_STRING_LITERAL", "UNCLOSED_TRIPLE_QUOTED_RAW_STRING_LITERAL", + "UNCLOSED_BYTES_LITERAL", "UNCLOSED_TRIPLE_QUOTED_BYTES_LITERAL", "UNCLOSED_RAW_BYTES_LITERAL", + "UNCLOSED_TRIPLE_QUOTED_RAW_BYTES_LITERAL", "FLOATING_POINT_LITERAL", + "INTEGER_LITERAL", "ARRAY_SYMBOL", "ALL_SYMBOL", "AS_SYMBOL", "ASC_SYMBOL", + "BY_SYMBOL", "CROSS_SYMBOL", "JOIN_SYMBOL", "DELTA_SYMBOL", "DESC_SYMBOL", + "DIFFERENTIAL_PRIVACY_SYMBOL", "DISTINCT_SYMBOL", "EPSILON_SYMBOL", + "EXCEPT_SYMBOL", "EXCLUDE_SYMBOL", "FOR_SYMBOL", "FROM_SYMBOL", "FULL_SYMBOL", + "IN_SYMBOL", "INCLUDE_SYMBOL", "INNER_SYMBOL", "INTERSECT_SYMBOL", "LEFT_SYMBOL", + "LIMIT_SYMBOL", "MAX_GROUPS_CONTRIBUTED_SYMBOL", "NULL_SYMBOL", "NULLS_SYMBOL", + "OF_SYMBOL", "OFFSET_SYMBOL", "ON_SYMBOL", "OPTIONS_SYMBOL", "ORDER_SYMBOL", + "OUTER_SYMBOL", "PERCENT_SYMBOL", "PIVOT_SYMBOL", "PRIVACY_UNIT_COLUMN_SYMBOL", + "RIGHT_SYMBOL", "RECURSIVE_SYMBOL", "REPLACE_SYMBOL", "UNPIVOT_SYMBOL", + "SELECT_SYMBOL", "STRUCT_SYMBOL", "SYSTEM_SYMBOL", "SYSTEM_TIME_SYMBOL", + "TABLESAMPLE_SYMBOL", "UNION_SYMBOL", "UNNEST_SYMBOL", "USING_SYMBOL", + "VALUE_SYMBOL", "WITH_SYMBOL", "TRUE_SYMBOL", "FALSE_SYMBOL", "NUMERIC_SYMBOL", + "DECIMAL_SYMBOL", "BIGNUMERIC_SYMBOL", "BIGDECIMAL_SYMBOL", "NOT_SYMBOL", + "AND_SYMBOL", "OR_SYMBOL", "JSON_SYMBOL", "DATE_SYMBOL", "TIME_SYMBOL", + "DATETIME_SYMBOL", "TIMESTAMP_SYMBOL", "RANGE_SYMBOL", "INTERVAL_SYMBOL", + "SIMPLE_SYMBOL", "ABORT_SYMBOL", "ACCESS_SYMBOL", "ACTION_SYMBOL", "AGGREGATE_SYMBOL", + "ADD_SYMBOL", "ALTER_SYMBOL", "ALWAYS_SYMBOL", "ANALYZE_SYMBOL", "APPROX_SYMBOL", + "ARE_SYMBOL", "ASSERT_SYMBOL", "BATCH_SYMBOL", "BEGIN_SYMBOL", "BREAK_SYMBOL", + "CALL_SYMBOL", "CASCADE_SYMBOL", "CHECK_SYMBOL", "CLAMPED_SYMBOL", "CLONE_SYMBOL", + "COPY_SYMBOL", "CLUSTER_SYMBOL", "COLUMN_SYMBOL", "COLUMNS_SYMBOL", + "COMMIT_SYMBOL", "CONNECTION_SYMBOL", "CONSTANT_SYMBOL", "CONSTRAINT_SYMBOL", + "CONTINUE_SYMBOL", "CORRESPONDING_SYMBOL", "CYCLE_SYMBOL", "DATA_SYMBOL", + "DATABASE_SYMBOL", "DECLARE_SYMBOL", "DEFINER_SYMBOL", "DELETE_SYMBOL", + "DELETION_SYMBOL", "DEPTH_SYMBOL", "DESCRIBE_SYMBOL", "DETERMINISTIC_SYMBOL", + "DO_SYMBOL", "DROP_SYMBOL", "ELSEIF_SYMBOL", "ENFORCED_SYMBOL", "ERROR_SYMBOL", + "EXCEPTION_SYMBOL", "EXECUTE_SYMBOL", "EXPLAIN_SYMBOL", "EXPORT_SYMBOL", + "EXTEND_SYMBOL", "EXTERNAL_SYMBOL", "FILES_SYMBOL", "FILTER_SYMBOL", + "FILL_SYMBOL", "FIRST_SYMBOL", "FOREIGN_SYMBOL", "FORMAT_SYMBOL", "FUNCTION_SYMBOL", + "GENERATED_SYMBOL", "GRANT_SYMBOL", "GROUP_ROWS_SYMBOL", "HIDDEN_SYMBOL", + "IDENTITY_SYMBOL", "IMMEDIATE_SYMBOL", "IMMUTABLE_SYMBOL", "IMPORT_SYMBOL", + "INCREMENT_SYMBOL", "INDEX_SYMBOL", "INOUT_SYMBOL", "INPUT_SYMBOL", + "INSERT_SYMBOL", "INVOKER_SYMBOL", "ISOLATION_SYMBOL", "ITERATE_SYMBOL", + "KEY_SYMBOL", "LANGUAGE_SYMBOL", "LAST_SYMBOL", "LEAVE_SYMBOL", "LEVEL_SYMBOL", + "LOAD_SYMBOL", "LOOP_SYMBOL", "MACRO_SYMBOL", "MAP_SYMBOL", "MATCH_SYMBOL", + "KW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL", "MATCHED_SYMBOL", "MATERIALIZED_SYMBOL", + "MAX_SYMBOL", "MAXVALUE_SYMBOL", "MEASURES_SYMBOL", "MESSAGE_SYMBOL", + "METADATA_SYMBOL", "MIN_SYMBOL", "MINVALUE_SYMBOL", "MODEL_SYMBOL", + "MODULE_SYMBOL", "ONLY_SYMBOL", "OUT_SYMBOL", "OUTPUT_SYMBOL", "OVERWRITE_SYMBOL", + "PARTITIONS_SYMBOL", "PATTERN_SYMBOL", "POLICIES_SYMBOL", "POLICY_SYMBOL", + "PRIMARY_SYMBOL", "PRIVATE_SYMBOL", "PRIVILEGE_SYMBOL", "PRIVILEGES_SYMBOL", + "PROCEDURE_SYMBOL", "PROJECT_SYMBOL", "PUBLIC_SYMBOL", "RAISE_SYMBOL", + "READ_SYMBOL", "REFERENCES_SYMBOL", "REMOTE_SYMBOL", "REMOVE_SYMBOL", + "RENAME_SYMBOL", "REPEAT_SYMBOL", "REPEATABLE_SYMBOL", "REPLACE_FIELDS_SYMBOL", + "REPLICA_SYMBOL", "REPORT_SYMBOL", "RESTRICT_SYMBOL", "RESTRICTION_SYMBOL", + "RETURNS_SYMBOL", "RETURN_SYMBOL", "REVOKE_SYMBOL", "ROLLBACK_SYMBOL", + "ROW_SYMBOL", "RUN_SYMBOL", "SAFE_CAST_SYMBOL", "SCHEMA_SYMBOL", "SEARCH_SYMBOL", + "SECURITY_SYMBOL", "SEQUENCE_SYMBOL", "SETS_SYMBOL", "SET_SYMBOL", "SHOW_SYMBOL", + "SNAPSHOT_SYMBOL", "SOURCE_SYMBOL", "SQL_SYMBOL", "STABLE_SYMBOL", "START_SYMBOL", + "STATIC_DESCRIBE_SYMBOL", "STORED_SYMBOL", "STORING_SYMBOL", "STRICT_SYMBOL", + "TABLE_SYMBOL", "TABLES_SYMBOL", "TARGET_SYMBOL", "TEMP_SYMBOL", "TEMPORARY_SYMBOL", + "TRANSACTION_SYMBOL", "TRANSFORM_SYMBOL", "TRUNCATE_SYMBOL", "TYPE_SYMBOL", + "UNDROP_SYMBOL", "UNIQUE_SYMBOL", "UNKNOWN_SYMBOL", "UNTIL_SYMBOL", + "UPDATE_SYMBOL", "VALUES_SYMBOL", "VECTOR_SYMBOL", "VIEW_SYMBOL", "VIEWS_SYMBOL", + "VOLATILE_SYMBOL", "WEIGHT_SYMBOL", "WHILE_SYMBOL", "WRITE_SYMBOL", + "ZONE_SYMBOL", "DESCRIPTOR_SYMBOL", "INTERLEAVE_SYMBOL", "NULL_FILTERED_SYMBOL", + "PARENT_SYMBOL", "NEW_SYMBOL", "END_SYMBOL", "CASE_SYMBOL", "WHEN_SYMBOL", + "THEN_SYMBOL", "ELSE_SYMBOL", "CAST_SYMBOL", "EXTRACT_SYMBOL", "COLLATE_SYMBOL", + "IF_SYMBOL", "GROUPING_SYMBOL", "HAVING_SYMBOL", "GROUP_SYMBOL", "ROLLUP_SYMBOL", + "CUBE_SYMBOL", "HASH_SYMBOL", "PROTO_SYMBOL", "PARTITION_SYMBOL", "IGNORE_SYMBOL", + "RESPECT_SYMBOL", "ROWS_SYMBOL", "OVER_SYMBOL", "BETWEEN_SYMBOL", "UNBOUNDED_SYMBOL", + "CURRENT_SYMBOL", "PRECEDING_SYMBOL", "FOLLOWING_SYMBOL", "NATURAL_SYMBOL", + "QUALIFY_SYMBOL", "DEFAULT_SYMBOL", "SLASH_SYMBOL", "MATCH_RECOGNIZE_SYMBOL", + "DEFINE_SYMBOL", "LOOKUP_SYMBOL", "WHERE_SYMBOL", "WINDOW_SYMBOL", "TO_SYMBOL", + "EXISTS_SYMBOL", "ANY_SYMBOL", "SOME_SYMBOL", "LIKE_SYMBOL", "IS_SYMBOL", + "NO_SYMBOL", "INTO_SYMBOL", "ASSERT_ROWS_MODIFIED_SYMBOL", "CONFLICT_SYMBOL", + "NOTHING_SYMBOL", "MERGE_SYMBOL", "CREATE_SYMBOL", "ENUM_SYMBOL", "DESTINATION_SYMBOL", + "PROPERTY_SYMBOL", "GRAPH_SYMBOL", "NODE_SYMBOL", "PROPERTIES_SYMBOL", + "LABEL_SYMBOL", "EDGE_SYMBOL", "NEXT_SYMBOL", "ASCENDING_SYMBOL", "DESCENDING_SYMBOL", + "SKIP_SYMBOL", "SHORTEST_SYMBOL", "PATH_SYMBOL", "PATHS_SYMBOL", "WALK_SYMBOL", + "TRAIL_SYMBOL", "ACYCLIC_SYMBOL", "OPTIONAL_SYMBOL", "LET_SYMBOL", "IDENTIFIER", + "UNCLOSED_ESCAPED_IDENTIFIER", "WHITESPACE", "COMMENT", + } + staticData.RuleNames = []string{ + "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", + "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "EQUAL_OPERATOR", + "NOT_EQUAL_OPERATOR", "NOT_EQUAL2_OPERATOR", "LT_OPERATOR", "LE_OPERATOR", + "GT_OPERATOR", "GE_OPERATOR", "KL_OPERATOR", "KR_OPERATOR", "PLUS_OPERATOR", + "MINUS_OPERATOR", "MULTIPLY_OPERATOR", "DIVIDE_OPERATOR", "BITWISE_NOT_OPERATOR", + "EXCLAMATION_OPERATOR", "MODULO_OPERATOR", "COMMA_SYMBOL", "DOT_SYMBOL", + "LC_BRACKET_SYMBOL", "RC_BRACKET_SYMBOL", "LR_BRACKET_SYMBOL", "RR_BRACKET_SYMBOL", + "LS_BRACKET_SYMBOL", "RS_BRACKET_SYMBOL", "STROKE_SYMBOL", "COLON_SYMBOL", + "SEMI_SYMBOL", "SINGLE_QUOTE_SYMBOL", "SINGLE_QUOTE_3_SYMBOL", "DOUBLE_QUOTE_SYMBOL", + "DOUBLE_QUOTE_3_SYMBOL", "BACKQUOTE_SYMBOL", "QUESTION_SYMBOL", "AT_SYMBOL", + "ATAT_SYMBOL", "EQUAL_GT_BRACKET_SYMBOL", "SUB_GT_BRACKET_SYMBOL", "PLUS_EQUAL_SYMBOL", + "SUB_EQUAL_SYMBOL", "PIPE_SYMBOL", "CIRCUMFLEX_SYMBOL", "BIT_AND_SYMBOL", + "BOOL_OR_SYMBOL", "ANY_ESCAPE", "NO_BACKSLASH_SINGLE_QUOTE_NEWLINE", + "NO_BACKSLASH_DOUBLE_QUOTE_NEWLINE", "NO_BACKSLASH_SINGLE_QUOTE", "NO_BACKSLASH_DOUBLE_QUOTE", + "SQTEXT_0", "SQTEXT", "DQTEXT_0", "DQTEXT", "SQ3TEXT_0", "SQ3TEXT", + "DQ3TEXT_0", "DQ3TEXT", "STRING_LITERAL", "BYTES_LITERAL", "UNCLOSED_STRING_LITERAL", + "UNCLOSED_TRIPLE_QUOTED_STRING_LITERAL", "UNCLOSED_RAW_STRING_LITERAL", + "UNCLOSED_TRIPLE_QUOTED_RAW_STRING_LITERAL", "UNCLOSED_BYTES_LITERAL", + "UNCLOSED_TRIPLE_QUOTED_BYTES_LITERAL", "UNCLOSED_RAW_BYTES_LITERAL", + "UNCLOSED_TRIPLE_QUOTED_RAW_BYTES_LITERAL", "FLOATING_POINT_LITERAL", + "INTEGER_LITERAL", "DECIMAL_DIGIT", "HEX_DIGIT", "DECIMAL_DIGITS", "HEX_DIGITS", + "ARRAY_SYMBOL", "ALL_SYMBOL", "AS_SYMBOL", "ASC_SYMBOL", "BY_SYMBOL", + "CROSS_SYMBOL", "JOIN_SYMBOL", "DELTA_SYMBOL", "DESC_SYMBOL", "DIFFERENTIAL_PRIVACY_SYMBOL", + "DISTINCT_SYMBOL", "EPSILON_SYMBOL", "EXCEPT_SYMBOL", "EXCLUDE_SYMBOL", + "FOR_SYMBOL", "FROM_SYMBOL", "FULL_SYMBOL", "IN_SYMBOL", "INCLUDE_SYMBOL", + "INNER_SYMBOL", "INTERSECT_SYMBOL", "LEFT_SYMBOL", "LIMIT_SYMBOL", "MAX_GROUPS_CONTRIBUTED_SYMBOL", + "NULL_SYMBOL", "NULLS_SYMBOL", "OF_SYMBOL", "OFFSET_SYMBOL", "ON_SYMBOL", + "OPTIONS_SYMBOL", "ORDER_SYMBOL", "OUTER_SYMBOL", "PERCENT_SYMBOL", + "PIVOT_SYMBOL", "PRIVACY_UNIT_COLUMN_SYMBOL", "RIGHT_SYMBOL", "RECURSIVE_SYMBOL", + "REPLACE_SYMBOL", "UNPIVOT_SYMBOL", "SELECT_SYMBOL", "STRUCT_SYMBOL", + "SYSTEM_SYMBOL", "SYSTEM_TIME_SYMBOL", "TABLESAMPLE_SYMBOL", "UNION_SYMBOL", + "UNNEST_SYMBOL", "USING_SYMBOL", "VALUE_SYMBOL", "WITH_SYMBOL", "TRUE_SYMBOL", + "FALSE_SYMBOL", "NUMERIC_SYMBOL", "DECIMAL_SYMBOL", "BIGNUMERIC_SYMBOL", + "BIGDECIMAL_SYMBOL", "NOT_SYMBOL", "AND_SYMBOL", "OR_SYMBOL", "JSON_SYMBOL", + "DATE_SYMBOL", "TIME_SYMBOL", "DATETIME_SYMBOL", "TIMESTAMP_SYMBOL", + "RANGE_SYMBOL", "INTERVAL_SYMBOL", "SIMPLE_SYMBOL", "ABORT_SYMBOL", + "ACCESS_SYMBOL", "ACTION_SYMBOL", "AGGREGATE_SYMBOL", "ADD_SYMBOL", + "ALTER_SYMBOL", "ALWAYS_SYMBOL", "ANALYZE_SYMBOL", "APPROX_SYMBOL", + "ARE_SYMBOL", "ASSERT_SYMBOL", "BATCH_SYMBOL", "BEGIN_SYMBOL", "BREAK_SYMBOL", + "CALL_SYMBOL", "CASCADE_SYMBOL", "CHECK_SYMBOL", "CLAMPED_SYMBOL", "CLONE_SYMBOL", + "COPY_SYMBOL", "CLUSTER_SYMBOL", "COLUMN_SYMBOL", "COLUMNS_SYMBOL", + "COMMIT_SYMBOL", "CONNECTION_SYMBOL", "CONSTANT_SYMBOL", "CONSTRAINT_SYMBOL", + "CONTINUE_SYMBOL", "CORRESPONDING_SYMBOL", "CYCLE_SYMBOL", "DATA_SYMBOL", + "DATABASE_SYMBOL", "DECLARE_SYMBOL", "DEFINER_SYMBOL", "DELETE_SYMBOL", + "DELETION_SYMBOL", "DEPTH_SYMBOL", "DESCRIBE_SYMBOL", "DETERMINISTIC_SYMBOL", + "DO_SYMBOL", "DROP_SYMBOL", "ELSEIF_SYMBOL", "ENFORCED_SYMBOL", "ERROR_SYMBOL", + "EXCEPTION_SYMBOL", "EXECUTE_SYMBOL", "EXPLAIN_SYMBOL", "EXPORT_SYMBOL", + "EXTEND_SYMBOL", "EXTERNAL_SYMBOL", "FILES_SYMBOL", "FILTER_SYMBOL", + "FILL_SYMBOL", "FIRST_SYMBOL", "FOREIGN_SYMBOL", "FORMAT_SYMBOL", "FUNCTION_SYMBOL", + "GENERATED_SYMBOL", "GRANT_SYMBOL", "GROUP_ROWS_SYMBOL", "HIDDEN_SYMBOL", + "IDENTITY_SYMBOL", "IMMEDIATE_SYMBOL", "IMMUTABLE_SYMBOL", "IMPORT_SYMBOL", + "INCREMENT_SYMBOL", "INDEX_SYMBOL", "INOUT_SYMBOL", "INPUT_SYMBOL", + "INSERT_SYMBOL", "INVOKER_SYMBOL", "ISOLATION_SYMBOL", "ITERATE_SYMBOL", + "KEY_SYMBOL", "LANGUAGE_SYMBOL", "LAST_SYMBOL", "LEAVE_SYMBOL", "LEVEL_SYMBOL", + "LOAD_SYMBOL", "LOOP_SYMBOL", "MACRO_SYMBOL", "MAP_SYMBOL", "MATCH_SYMBOL", + "KW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL", "MATCHED_SYMBOL", "MATERIALIZED_SYMBOL", + "MAX_SYMBOL", "MAXVALUE_SYMBOL", "MEASURES_SYMBOL", "MESSAGE_SYMBOL", + "METADATA_SYMBOL", "MIN_SYMBOL", "MINVALUE_SYMBOL", "MODEL_SYMBOL", + "MODULE_SYMBOL", "ONLY_SYMBOL", "OUT_SYMBOL", "OUTPUT_SYMBOL", "OVERWRITE_SYMBOL", + "PARTITIONS_SYMBOL", "PATTERN_SYMBOL", "POLICIES_SYMBOL", "POLICY_SYMBOL", + "PRIMARY_SYMBOL", "PRIVATE_SYMBOL", "PRIVILEGE_SYMBOL", "PRIVILEGES_SYMBOL", + "PROCEDURE_SYMBOL", "PROJECT_SYMBOL", "PUBLIC_SYMBOL", "RAISE_SYMBOL", + "READ_SYMBOL", "REFERENCES_SYMBOL", "REMOTE_SYMBOL", "REMOVE_SYMBOL", + "RENAME_SYMBOL", "REPEAT_SYMBOL", "REPEATABLE_SYMBOL", "REPLACE_FIELDS_SYMBOL", + "REPLICA_SYMBOL", "REPORT_SYMBOL", "RESTRICT_SYMBOL", "RESTRICTION_SYMBOL", + "RETURNS_SYMBOL", "RETURN_SYMBOL", "REVOKE_SYMBOL", "ROLLBACK_SYMBOL", + "ROW_SYMBOL", "RUN_SYMBOL", "SAFE_CAST_SYMBOL", "SCHEMA_SYMBOL", "SEARCH_SYMBOL", + "SECURITY_SYMBOL", "SEQUENCE_SYMBOL", "SETS_SYMBOL", "SET_SYMBOL", "SHOW_SYMBOL", + "SNAPSHOT_SYMBOL", "SOURCE_SYMBOL", "SQL_SYMBOL", "STABLE_SYMBOL", "START_SYMBOL", + "STATIC_DESCRIBE_SYMBOL", "STORED_SYMBOL", "STORING_SYMBOL", "STRICT_SYMBOL", + "TABLE_SYMBOL", "TABLES_SYMBOL", "TARGET_SYMBOL", "TEMP_SYMBOL", "TEMPORARY_SYMBOL", + "TRANSACTION_SYMBOL", "TRANSFORM_SYMBOL", "TRUNCATE_SYMBOL", "TYPE_SYMBOL", + "UNDROP_SYMBOL", "UNIQUE_SYMBOL", "UNKNOWN_SYMBOL", "UNTIL_SYMBOL", + "UPDATE_SYMBOL", "VALUES_SYMBOL", "VECTOR_SYMBOL", "VIEW_SYMBOL", "VIEWS_SYMBOL", + "VOLATILE_SYMBOL", "WEIGHT_SYMBOL", "WHILE_SYMBOL", "WRITE_SYMBOL", + "ZONE_SYMBOL", "DESCRIPTOR_SYMBOL", "INTERLEAVE_SYMBOL", "NULL_FILTERED_SYMBOL", + "PARENT_SYMBOL", "NEW_SYMBOL", "END_SYMBOL", "CASE_SYMBOL", "WHEN_SYMBOL", + "THEN_SYMBOL", "ELSE_SYMBOL", "CAST_SYMBOL", "EXTRACT_SYMBOL", "COLLATE_SYMBOL", + "IF_SYMBOL", "GROUPING_SYMBOL", "HAVING_SYMBOL", "GROUP_SYMBOL", "ROLLUP_SYMBOL", + "CUBE_SYMBOL", "HASH_SYMBOL", "PROTO_SYMBOL", "PARTITION_SYMBOL", "IGNORE_SYMBOL", + "RESPECT_SYMBOL", "ROWS_SYMBOL", "OVER_SYMBOL", "BETWEEN_SYMBOL", "UNBOUNDED_SYMBOL", + "CURRENT_SYMBOL", "PRECEDING_SYMBOL", "FOLLOWING_SYMBOL", "NATURAL_SYMBOL", + "QUALIFY_SYMBOL", "DEFAULT_SYMBOL", "SLASH_SYMBOL", "MATCH_RECOGNIZE_SYMBOL", + "DEFINE_SYMBOL", "LOOKUP_SYMBOL", "WHERE_SYMBOL", "WINDOW_SYMBOL", "TO_SYMBOL", + "EXISTS_SYMBOL", "ANY_SYMBOL", "SOME_SYMBOL", "LIKE_SYMBOL", "IS_SYMBOL", + "NO_SYMBOL", "INTO_SYMBOL", "ASSERT_ROWS_MODIFIED_SYMBOL", "CONFLICT_SYMBOL", + "NOTHING_SYMBOL", "MERGE_SYMBOL", "CREATE_SYMBOL", "ENUM_SYMBOL", "DESTINATION_SYMBOL", + "PROPERTY_SYMBOL", "GRAPH_SYMBOL", "NODE_SYMBOL", "PROPERTIES_SYMBOL", + "LABEL_SYMBOL", "EDGE_SYMBOL", "NEXT_SYMBOL", "ASCENDING_SYMBOL", "DESCENDING_SYMBOL", + "SKIP_SYMBOL", "SHORTEST_SYMBOL", "PATH_SYMBOL", "PATHS_SYMBOL", "WALK_SYMBOL", + "TRAIL_SYMBOL", "ACYCLIC_SYMBOL", "OPTIONAL_SYMBOL", "LET_SYMBOL", "EXPONENT_WITHOUT_SIGN", + "UNQUOTED_IDENTIFIER", "BQTEXT_0", "BQTEXT", "IDENTIFIER", "UNCLOSED_ESCAPED_IDENTIFIER", + "WHITESPACE", "BLOCK_COMMENT", "DASH_COMMENT", "POUND_COMMENT", "COMMENT", + } + staticData.PredictionContextCache = antlr.NewPredictionContextCache() + staticData.serializedATN = []int32{ + 4, 0, 367, 3578, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, + 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, + 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, + 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, + 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, + 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, + 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, + 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, + 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, + 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, + 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, + 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, + 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, + 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, + 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, + 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, + 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, + 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, + 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, + 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, + 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, + 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, + 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, + 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, + 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, + 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, + 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, + 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, + 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, + 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, + 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, + 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, + 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, + 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, + 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, + 7, 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175, + 2, 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, 180, + 7, 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, 184, + 2, 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, 189, + 7, 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, 193, + 2, 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 2, 198, + 7, 198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, 7, 201, 2, 202, 7, 202, + 2, 203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, 2, 206, 7, 206, 2, 207, + 7, 207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, 7, 210, 2, 211, 7, 211, + 2, 212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, 2, 215, 7, 215, 2, 216, + 7, 216, 2, 217, 7, 217, 2, 218, 7, 218, 2, 219, 7, 219, 2, 220, 7, 220, + 2, 221, 7, 221, 2, 222, 7, 222, 2, 223, 7, 223, 2, 224, 7, 224, 2, 225, + 7, 225, 2, 226, 7, 226, 2, 227, 7, 227, 2, 228, 7, 228, 2, 229, 7, 229, + 2, 230, 7, 230, 2, 231, 7, 231, 2, 232, 7, 232, 2, 233, 7, 233, 2, 234, + 7, 234, 2, 235, 7, 235, 2, 236, 7, 236, 2, 237, 7, 237, 2, 238, 7, 238, + 2, 239, 7, 239, 2, 240, 7, 240, 2, 241, 7, 241, 2, 242, 7, 242, 2, 243, + 7, 243, 2, 244, 7, 244, 2, 245, 7, 245, 2, 246, 7, 246, 2, 247, 7, 247, + 2, 248, 7, 248, 2, 249, 7, 249, 2, 250, 7, 250, 2, 251, 7, 251, 2, 252, + 7, 252, 2, 253, 7, 253, 2, 254, 7, 254, 2, 255, 7, 255, 2, 256, 7, 256, + 2, 257, 7, 257, 2, 258, 7, 258, 2, 259, 7, 259, 2, 260, 7, 260, 2, 261, + 7, 261, 2, 262, 7, 262, 2, 263, 7, 263, 2, 264, 7, 264, 2, 265, 7, 265, + 2, 266, 7, 266, 2, 267, 7, 267, 2, 268, 7, 268, 2, 269, 7, 269, 2, 270, + 7, 270, 2, 271, 7, 271, 2, 272, 7, 272, 2, 273, 7, 273, 2, 274, 7, 274, + 2, 275, 7, 275, 2, 276, 7, 276, 2, 277, 7, 277, 2, 278, 7, 278, 2, 279, + 7, 279, 2, 280, 7, 280, 2, 281, 7, 281, 2, 282, 7, 282, 2, 283, 7, 283, + 2, 284, 7, 284, 2, 285, 7, 285, 2, 286, 7, 286, 2, 287, 7, 287, 2, 288, + 7, 288, 2, 289, 7, 289, 2, 290, 7, 290, 2, 291, 7, 291, 2, 292, 7, 292, + 2, 293, 7, 293, 2, 294, 7, 294, 2, 295, 7, 295, 2, 296, 7, 296, 2, 297, + 7, 297, 2, 298, 7, 298, 2, 299, 7, 299, 2, 300, 7, 300, 2, 301, 7, 301, + 2, 302, 7, 302, 2, 303, 7, 303, 2, 304, 7, 304, 2, 305, 7, 305, 2, 306, + 7, 306, 2, 307, 7, 307, 2, 308, 7, 308, 2, 309, 7, 309, 2, 310, 7, 310, + 2, 311, 7, 311, 2, 312, 7, 312, 2, 313, 7, 313, 2, 314, 7, 314, 2, 315, + 7, 315, 2, 316, 7, 316, 2, 317, 7, 317, 2, 318, 7, 318, 2, 319, 7, 319, + 2, 320, 7, 320, 2, 321, 7, 321, 2, 322, 7, 322, 2, 323, 7, 323, 2, 324, + 7, 324, 2, 325, 7, 325, 2, 326, 7, 326, 2, 327, 7, 327, 2, 328, 7, 328, + 2, 329, 7, 329, 2, 330, 7, 330, 2, 331, 7, 331, 2, 332, 7, 332, 2, 333, + 7, 333, 2, 334, 7, 334, 2, 335, 7, 335, 2, 336, 7, 336, 2, 337, 7, 337, + 2, 338, 7, 338, 2, 339, 7, 339, 2, 340, 7, 340, 2, 341, 7, 341, 2, 342, + 7, 342, 2, 343, 7, 343, 2, 344, 7, 344, 2, 345, 7, 345, 2, 346, 7, 346, + 2, 347, 7, 347, 2, 348, 7, 348, 2, 349, 7, 349, 2, 350, 7, 350, 2, 351, + 7, 351, 2, 352, 7, 352, 2, 353, 7, 353, 2, 354, 7, 354, 2, 355, 7, 355, + 2, 356, 7, 356, 2, 357, 7, 357, 2, 358, 7, 358, 2, 359, 7, 359, 2, 360, + 7, 360, 2, 361, 7, 361, 2, 362, 7, 362, 2, 363, 7, 363, 2, 364, 7, 364, + 2, 365, 7, 365, 2, 366, 7, 366, 2, 367, 7, 367, 2, 368, 7, 368, 2, 369, + 7, 369, 2, 370, 7, 370, 2, 371, 7, 371, 2, 372, 7, 372, 2, 373, 7, 373, + 2, 374, 7, 374, 2, 375, 7, 375, 2, 376, 7, 376, 2, 377, 7, 377, 2, 378, + 7, 378, 2, 379, 7, 379, 2, 380, 7, 380, 2, 381, 7, 381, 2, 382, 7, 382, + 2, 383, 7, 383, 2, 384, 7, 384, 2, 385, 7, 385, 2, 386, 7, 386, 2, 387, + 7, 387, 2, 388, 7, 388, 2, 389, 7, 389, 2, 390, 7, 390, 2, 391, 7, 391, + 2, 392, 7, 392, 2, 393, 7, 393, 2, 394, 7, 394, 2, 395, 7, 395, 2, 396, + 7, 396, 2, 397, 7, 397, 2, 398, 7, 398, 2, 399, 7, 399, 2, 400, 7, 400, + 2, 401, 7, 401, 2, 402, 7, 402, 2, 403, 7, 403, 2, 404, 7, 404, 2, 405, + 7, 405, 2, 406, 7, 406, 2, 407, 7, 407, 2, 408, 7, 408, 2, 409, 7, 409, + 2, 410, 7, 410, 2, 411, 7, 411, 2, 412, 7, 412, 2, 413, 7, 413, 2, 414, + 7, 414, 2, 415, 7, 415, 2, 416, 7, 416, 1, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, + 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 6, 1, 6, 1, 7, 1, 7, 1, 8, 1, + 8, 1, 9, 1, 9, 1, 10, 1, 10, 1, 11, 1, 11, 1, 12, 1, 12, 1, 13, 1, 13, + 1, 14, 1, 14, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, + 19, 1, 19, 1, 20, 1, 20, 1, 21, 1, 21, 1, 22, 1, 22, 1, 23, 1, 23, 1, 24, + 1, 24, 1, 25, 1, 25, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, + 28, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, + 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 36, 1, 36, 1, + 37, 1, 37, 1, 38, 1, 38, 1, 39, 1, 39, 1, 40, 1, 40, 1, 41, 1, 41, 1, 42, + 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 45, 1, 45, 1, 46, 1, 46, 1, 47, 1, + 47, 1, 48, 1, 48, 1, 49, 1, 49, 1, 50, 1, 50, 1, 51, 1, 51, 1, 52, 1, 52, + 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 56, 1, 56, 1, + 56, 1, 56, 1, 57, 1, 57, 1, 58, 1, 58, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, + 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 64, 1, + 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 67, 1, 67, 1, 68, 1, 68, + 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 3, + 69, 1000, 8, 69, 1, 70, 1, 70, 1, 71, 1, 71, 1, 72, 1, 72, 1, 73, 1, 73, + 1, 74, 1, 74, 1, 74, 5, 74, 1013, 8, 74, 10, 74, 12, 74, 1016, 9, 74, 1, + 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 5, 76, 1024, 8, 76, 10, 76, 12, + 76, 1027, 9, 76, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 3, 78, 1035, + 8, 78, 3, 78, 1037, 8, 78, 1, 78, 1, 78, 3, 78, 1041, 8, 78, 5, 78, 1043, + 8, 78, 10, 78, 12, 78, 1046, 9, 78, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, + 1, 80, 3, 80, 1054, 8, 80, 3, 80, 1056, 8, 80, 1, 80, 1, 80, 3, 80, 1060, + 8, 80, 5, 80, 1062, 8, 80, 10, 80, 12, 80, 1065, 9, 80, 1, 81, 1, 81, 1, + 81, 1, 82, 3, 82, 1071, 8, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1077, + 8, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 3, 83, 1086, 8, + 83, 1, 83, 1, 83, 1, 83, 1, 83, 3, 83, 1092, 8, 83, 1, 84, 1, 84, 3, 84, + 1096, 8, 84, 1, 85, 1, 85, 3, 85, 1100, 8, 85, 1, 86, 1, 86, 1, 86, 3, + 86, 1105, 8, 86, 1, 87, 1, 87, 1, 87, 3, 87, 1110, 8, 87, 1, 88, 1, 88, + 1, 88, 3, 88, 1115, 8, 88, 1, 89, 1, 89, 1, 89, 3, 89, 1120, 8, 89, 1, + 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 3, 90, 1128, 8, 90, 1, 90, 1, 90, + 3, 90, 1132, 8, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 1140, + 8, 91, 1, 91, 1, 91, 3, 91, 1144, 8, 91, 1, 92, 1, 92, 3, 92, 1148, 8, + 92, 1, 92, 1, 92, 1, 92, 3, 92, 1153, 8, 92, 1, 92, 1, 92, 1, 92, 3, 92, + 1158, 8, 92, 1, 92, 3, 92, 1161, 8, 92, 1, 92, 1, 92, 3, 92, 1165, 8, 92, + 1, 92, 3, 92, 1168, 8, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 1175, + 8, 92, 1, 92, 3, 92, 1178, 8, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 1184, + 8, 92, 1, 92, 1, 92, 3, 92, 1188, 8, 92, 1, 93, 1, 93, 3, 93, 1192, 8, + 93, 1, 94, 1, 94, 1, 95, 1, 95, 1, 96, 4, 96, 1199, 8, 96, 11, 96, 12, + 96, 1200, 1, 97, 1, 97, 1, 97, 1, 97, 4, 97, 1207, 8, 97, 11, 97, 12, 97, + 1208, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, + 99, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, + 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 104, 1, + 104, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, + 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, + 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, + 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, + 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, + 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, + 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, + 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, + 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, + 114, 1, 115, 1, 115, 1, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, + 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, + 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, + 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1, + 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, + 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, + 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 122, 1, + 122, 1, 122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, + 123, 1, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, + 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, + 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, + 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 130, 1, 130, 1, + 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 131, 1, + 131, 1, 131, 1, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, + 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, + 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, + 133, 1, 133, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, + 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, + 135, 1, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, + 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 138, 1, + 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, + 139, 1, 139, 1, 139, 1, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, + 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 141, 1, 141, 1, + 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, + 141, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, + 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, + 144, 1, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 146, 1, + 146, 1, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, + 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 1, + 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, + 150, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, + 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 1, + 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 153, 1, + 153, 1, 153, 1, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 155, 1, 155, 1, + 155, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 157, 1, 157, 1, 157, 1, + 157, 1, 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 159, 1, 159, 1, + 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 160, 1, 160, 1, + 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 161, 1, + 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 162, 1, 162, 1, 162, 1, 162, 1, + 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, + 163, 1, 163, 1, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, + 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, + 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, + 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 168, 1, 168, 1, 168, 1, + 168, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 170, 1, 170, 1, + 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, + 171, 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, + 172, 1, 172, 1, 173, 1, 173, 1, 173, 1, 173, 1, 174, 1, 174, 1, 174, 1, + 174, 1, 174, 1, 174, 1, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, + 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 177, 1, 177, 1, + 177, 1, 177, 1, 177, 1, 177, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, + 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 180, 1, + 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, + 181, 1, 181, 1, 181, 1, 181, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, + 182, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 184, 1, 184, 1, 184, 1, + 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 185, 1, 185, 1, 185, 1, 185, 1, + 185, 1, 185, 1, 185, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, + 186, 1, 186, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, + 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, + 188, 1, 188, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, + 189, 1, 189, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, + 190, 1, 190, 1, 190, 1, 190, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, + 191, 1, 191, 1, 191, 1, 191, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, + 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, + 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 194, 1, 194, 1, 194, 1, + 194, 1, 194, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, + 195, 1, 195, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, + 196, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, + 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 199, 1, 199, 1, + 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 200, 1, 200, 1, + 200, 1, 200, 1, 200, 1, 200, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, + 201, 1, 201, 1, 201, 1, 201, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, + 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, + 203, 1, 203, 1, 203, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 205, 1, + 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 206, 1, 206, 1, 206, 1, + 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 207, 1, 207, 1, 207, 1, + 207, 1, 207, 1, 207, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, + 208, 1, 208, 1, 208, 1, 208, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, + 209, 1, 209, 1, 209, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, + 210, 1, 210, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, + 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 213, 1, 213, 1, + 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 214, 1, 214, 1, + 214, 1, 214, 1, 214, 1, 214, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, + 215, 1, 215, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 217, 1, 217, 1, + 217, 1, 217, 1, 217, 1, 217, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, + 218, 1, 218, 1, 218, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, + 219, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, + 220, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, + 221, 1, 221, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 223, 1, + 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, + 223, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 225, 1, + 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 226, 1, + 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, + 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, + 227, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 229, 1, + 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, + 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 231, 1, 231, 1, 231, 1, + 231, 1, 231, 1, 231, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, + 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 234, 1, 234, 1, + 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 235, 1, 235, 1, 235, 1, + 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 236, 1, 236, 1, + 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 237, 1, 237, 1, 237, 1, + 237, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, + 238, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 240, 1, 240, 1, 240, 1, + 240, 1, 240, 1, 240, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, + 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 243, 1, 243, 1, 243, 1, 243, 1, + 243, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 245, 1, 245, 1, + 245, 1, 245, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 247, 1, + 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, + 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, + 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, + 247, 1, 247, 1, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, + 248, 1, 248, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, + 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 250, 1, 250, 1, 250, 1, + 250, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, + 251, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, + 252, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, + 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, + 255, 1, 255, 1, 255, 1, 255, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, + 256, 1, 256, 1, 256, 1, 256, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, + 257, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 259, 1, + 259, 1, 259, 1, 259, 1, 259, 1, 260, 1, 260, 1, 260, 1, 260, 1, 261, 1, + 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 262, 1, 262, 1, 262, 1, + 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 263, 1, 263, 1, + 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, + 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 265, 1, + 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 266, 1, + 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 267, 1, 267, 1, 267, 1, + 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 268, 1, 268, 1, 268, 1, 268, 1, + 268, 1, 268, 1, 268, 1, 268, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, + 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 270, 1, 270, 1, 270, 1, 270, 1, + 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 271, 1, 271, 1, + 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 272, 1, + 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 273, 1, 273, 1, + 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 274, 1, 274, 1, 274, 1, 274, 1, + 274, 1, 274, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 276, 1, 276, 1, + 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, + 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 278, 1, 278, 1, + 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 279, 1, 279, 1, 279, 1, 279, 1, + 279, 1, 279, 1, 279, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, + 280, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, + 281, 1, 281, 1, 281, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, + 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, + 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, 284, 1, + 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 285, 1, 285, 1, 285, 1, + 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 286, 1, 286, 1, 286, 1, + 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, + 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 288, 1, + 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 289, 1, 289, 1, 289, 1, + 289, 1, 289, 1, 289, 1, 289, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, + 290, 1, 290, 1, 290, 1, 290, 1, 291, 1, 291, 1, 291, 1, 291, 1, 292, 1, + 292, 1, 292, 1, 292, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, + 293, 1, 293, 1, 293, 1, 293, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, + 294, 1, 294, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, + 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, + 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, + 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 299, 1, 299, 1, 299, 1, 299, 1, + 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 301, 1, 301, 1, 301, 1, 301, 1, + 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 302, 1, 302, 1, 302, 1, 302, 1, + 302, 1, 302, 1, 302, 1, 303, 1, 303, 1, 303, 1, 303, 1, 304, 1, 304, 1, + 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 305, 1, 305, 1, 305, 1, 305, 1, + 305, 1, 305, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, + 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, + 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 308, 1, 308, 1, + 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 309, 1, 309, 1, 309, 1, + 309, 1, 309, 1, 309, 1, 309, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, + 310, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 312, 1, + 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 313, 1, 313, 1, 313, 1, + 313, 1, 313, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, + 314, 1, 314, 1, 314, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, + 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 316, 1, 316, 1, 316, 1, + 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 317, 1, 317, 1, + 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 318, 1, 318, 1, + 318, 1, 318, 1, 318, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, + 319, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 321, 1, + 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 322, 1, 322, 1, + 322, 1, 322, 1, 322, 1, 322, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, + 323, 1, 323, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, + 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 326, 1, 326, 1, + 326, 1, 326, 1, 326, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, + 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, + 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 330, 1, 330, 1, + 330, 1, 330, 1, 330, 1, 330, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, + 331, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 333, 1, 333, 1, 333, 1, + 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 334, 1, + 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, + 334, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, + 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 336, 1, 336, 1, 336, 1, + 336, 1, 336, 1, 336, 1, 336, 1, 337, 1, 337, 1, 337, 1, 337, 1, 338, 1, + 338, 1, 338, 1, 338, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 340, 1, + 340, 1, 340, 1, 340, 1, 340, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, + 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 343, 1, 343, 1, 343, 1, 343, 1, + 343, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, + 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 346, 1, + 346, 1, 346, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, + 347, 1, 347, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, + 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 350, 1, 350, 1, 350, 1, + 350, 1, 350, 1, 350, 1, 350, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, + 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 353, 1, 353, 1, 353, 1, 353, 1, + 353, 1, 353, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, + 354, 1, 354, 1, 354, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, + 355, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, + 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 358, 1, 358, 1, 358, 1, 358, 1, + 358, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, + 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, + 360, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, + 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, + 362, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, + 363, 1, 363, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, + 364, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, + 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 367, 1, + 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 368, 1, 368, 1, 368, 1, 368, 1, + 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, + 368, 1, 368, 1, 368, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, + 369, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 371, 1, + 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 372, 1, 372, 1, 372, 1, 372, 1, + 372, 1, 372, 1, 372, 1, 373, 1, 373, 1, 373, 1, 374, 1, 374, 1, 374, 1, + 374, 1, 374, 1, 374, 1, 374, 1, 375, 1, 375, 1, 375, 1, 375, 1, 376, 1, + 376, 1, 376, 1, 376, 1, 376, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, + 378, 1, 378, 1, 378, 1, 379, 1, 379, 1, 379, 1, 380, 1, 380, 1, 380, 1, + 380, 1, 380, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, + 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, + 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 382, 1, 382, 1, 382, 1, 382, 1, + 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 383, 1, 383, 1, 383, 1, 383, 1, + 383, 1, 383, 1, 383, 1, 383, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, + 384, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 386, 1, + 386, 1, 386, 1, 386, 1, 386, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, + 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 388, 1, 388, 1, + 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 389, 1, 389, 1, + 389, 1, 389, 1, 389, 1, 389, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, + 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, + 391, 1, 391, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 393, 1, + 393, 1, 393, 1, 393, 1, 393, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, + 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, + 395, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, + 396, 1, 396, 1, 396, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 398, 1, + 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 399, 1, + 399, 1, 399, 1, 399, 1, 399, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, + 400, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 402, 1, 402, 1, 402, 1, + 402, 1, 402, 1, 402, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, + 403, 1, 403, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, + 404, 1, 404, 1, 405, 1, 405, 1, 405, 1, 405, 1, 406, 1, 406, 4, 406, 3496, + 8, 406, 11, 406, 12, 406, 3497, 1, 407, 1, 407, 5, 407, 3502, 8, 407, 10, + 407, 12, 407, 3505, 9, 407, 1, 408, 1, 408, 1, 408, 5, 408, 3510, 8, 408, + 10, 408, 12, 408, 3513, 9, 408, 1, 409, 1, 409, 1, 409, 1, 410, 1, 410, + 3, 410, 3520, 8, 410, 1, 411, 1, 411, 1, 412, 1, 412, 1, 412, 1, 412, 1, + 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 5, + 413, 3537, 8, 413, 10, 413, 12, 413, 3540, 9, 413, 1, 413, 1, 413, 3, 413, + 3544, 8, 413, 1, 414, 1, 414, 1, 414, 1, 414, 5, 414, 3550, 8, 414, 10, + 414, 12, 414, 3553, 9, 414, 1, 414, 1, 414, 1, 414, 3, 414, 3558, 8, 414, + 1, 415, 1, 415, 5, 415, 3562, 8, 415, 10, 415, 12, 415, 3565, 9, 415, 1, + 415, 1, 415, 1, 415, 3, 415, 3570, 8, 415, 1, 416, 1, 416, 1, 416, 3, 416, + 3575, 8, 416, 1, 416, 1, 416, 1, 3538, 0, 417, 1, 0, 3, 0, 5, 0, 7, 0, + 9, 0, 11, 0, 13, 0, 15, 0, 17, 0, 19, 0, 21, 0, 23, 0, 25, 0, 27, 0, 29, + 0, 31, 0, 33, 0, 35, 0, 37, 0, 39, 0, 41, 0, 43, 0, 45, 0, 47, 0, 49, 0, + 51, 0, 53, 1, 55, 2, 57, 3, 59, 4, 61, 5, 63, 6, 65, 7, 67, 8, 69, 9, 71, + 10, 73, 11, 75, 12, 77, 13, 79, 14, 81, 15, 83, 16, 85, 17, 87, 18, 89, + 19, 91, 20, 93, 21, 95, 22, 97, 23, 99, 24, 101, 25, 103, 26, 105, 27, + 107, 28, 109, 29, 111, 30, 113, 31, 115, 32, 117, 33, 119, 34, 121, 35, + 123, 36, 125, 37, 127, 38, 129, 39, 131, 40, 133, 41, 135, 42, 137, 43, + 139, 0, 141, 0, 143, 0, 145, 0, 147, 0, 149, 0, 151, 0, 153, 0, 155, 0, + 157, 0, 159, 0, 161, 0, 163, 0, 165, 44, 167, 45, 169, 46, 171, 47, 173, + 48, 175, 49, 177, 50, 179, 51, 181, 52, 183, 53, 185, 54, 187, 55, 189, + 0, 191, 0, 193, 0, 195, 0, 197, 56, 199, 57, 201, 58, 203, 59, 205, 60, + 207, 61, 209, 62, 211, 63, 213, 64, 215, 65, 217, 66, 219, 67, 221, 68, + 223, 69, 225, 70, 227, 71, 229, 72, 231, 73, 233, 74, 235, 75, 237, 76, + 239, 77, 241, 78, 243, 79, 245, 80, 247, 81, 249, 82, 251, 83, 253, 84, + 255, 85, 257, 86, 259, 87, 261, 88, 263, 89, 265, 90, 267, 91, 269, 92, + 271, 93, 273, 94, 275, 95, 277, 96, 279, 97, 281, 98, 283, 99, 285, 100, + 287, 101, 289, 102, 291, 103, 293, 104, 295, 105, 297, 106, 299, 107, 301, + 108, 303, 109, 305, 110, 307, 111, 309, 112, 311, 113, 313, 114, 315, 115, + 317, 116, 319, 117, 321, 118, 323, 119, 325, 120, 327, 121, 329, 122, 331, + 123, 333, 124, 335, 125, 337, 126, 339, 127, 341, 128, 343, 129, 345, 130, + 347, 131, 349, 132, 351, 133, 353, 134, 355, 135, 357, 136, 359, 137, 361, + 138, 363, 139, 365, 140, 367, 141, 369, 142, 371, 143, 373, 144, 375, 145, + 377, 146, 379, 147, 381, 148, 383, 149, 385, 150, 387, 151, 389, 152, 391, + 153, 393, 154, 395, 155, 397, 156, 399, 157, 401, 158, 403, 159, 405, 160, + 407, 161, 409, 162, 411, 163, 413, 164, 415, 165, 417, 166, 419, 167, 421, + 168, 423, 169, 425, 170, 427, 171, 429, 172, 431, 173, 433, 174, 435, 175, + 437, 176, 439, 177, 441, 178, 443, 179, 445, 180, 447, 181, 449, 182, 451, + 183, 453, 184, 455, 185, 457, 186, 459, 187, 461, 188, 463, 189, 465, 190, + 467, 191, 469, 192, 471, 193, 473, 194, 475, 195, 477, 196, 479, 197, 481, + 198, 483, 199, 485, 200, 487, 201, 489, 202, 491, 203, 493, 204, 495, 205, + 497, 206, 499, 207, 501, 208, 503, 209, 505, 210, 507, 211, 509, 212, 511, + 213, 513, 214, 515, 215, 517, 216, 519, 217, 521, 218, 523, 219, 525, 220, + 527, 221, 529, 222, 531, 223, 533, 224, 535, 225, 537, 226, 539, 227, 541, + 228, 543, 229, 545, 230, 547, 231, 549, 232, 551, 233, 553, 234, 555, 235, + 557, 236, 559, 237, 561, 238, 563, 239, 565, 240, 567, 241, 569, 242, 571, + 243, 573, 244, 575, 245, 577, 246, 579, 247, 581, 248, 583, 249, 585, 250, + 587, 251, 589, 252, 591, 253, 593, 254, 595, 255, 597, 256, 599, 257, 601, + 258, 603, 259, 605, 260, 607, 261, 609, 262, 611, 263, 613, 264, 615, 265, + 617, 266, 619, 267, 621, 268, 623, 269, 625, 270, 627, 271, 629, 272, 631, + 273, 633, 274, 635, 275, 637, 276, 639, 277, 641, 278, 643, 279, 645, 280, + 647, 281, 649, 282, 651, 283, 653, 284, 655, 285, 657, 286, 659, 287, 661, + 288, 663, 289, 665, 290, 667, 291, 669, 292, 671, 293, 673, 294, 675, 295, + 677, 296, 679, 297, 681, 298, 683, 299, 685, 300, 687, 301, 689, 302, 691, + 303, 693, 304, 695, 305, 697, 306, 699, 307, 701, 308, 703, 309, 705, 310, + 707, 311, 709, 312, 711, 313, 713, 314, 715, 315, 717, 316, 719, 317, 721, + 318, 723, 319, 725, 320, 727, 321, 729, 322, 731, 323, 733, 324, 735, 325, + 737, 326, 739, 327, 741, 328, 743, 329, 745, 330, 747, 331, 749, 332, 751, + 333, 753, 334, 755, 335, 757, 336, 759, 337, 761, 338, 763, 339, 765, 340, + 767, 341, 769, 342, 771, 343, 773, 344, 775, 345, 777, 346, 779, 347, 781, + 348, 783, 349, 785, 350, 787, 351, 789, 352, 791, 353, 793, 354, 795, 355, + 797, 356, 799, 357, 801, 358, 803, 359, 805, 360, 807, 361, 809, 362, 811, + 363, 813, 0, 815, 0, 817, 0, 819, 0, 821, 364, 823, 365, 825, 366, 827, + 0, 829, 0, 831, 0, 833, 367, 1, 0, 38, 2, 0, 65, 65, 97, 97, 2, 0, 66, + 66, 98, 98, 2, 0, 67, 67, 99, 99, 2, 0, 68, 68, 100, 100, 2, 0, 69, 69, + 101, 101, 2, 0, 70, 70, 102, 102, 2, 0, 71, 71, 103, 103, 2, 0, 72, 72, + 104, 104, 2, 0, 73, 73, 105, 105, 2, 0, 74, 74, 106, 106, 2, 0, 75, 75, + 107, 107, 2, 0, 76, 76, 108, 108, 2, 0, 77, 77, 109, 109, 2, 0, 78, 78, + 110, 110, 2, 0, 79, 79, 111, 111, 2, 0, 80, 80, 112, 112, 2, 0, 81, 81, + 113, 113, 2, 0, 82, 82, 114, 114, 2, 0, 83, 83, 115, 115, 2, 0, 84, 84, + 116, 116, 2, 0, 85, 85, 117, 117, 2, 0, 86, 86, 118, 118, 2, 0, 87, 87, + 119, 119, 2, 0, 88, 88, 120, 120, 2, 0, 89, 89, 121, 121, 2, 0, 90, 90, + 122, 122, 4, 0, 10, 10, 13, 13, 39, 39, 92, 92, 4, 0, 10, 10, 13, 13, 34, + 34, 92, 92, 2, 0, 39, 39, 92, 92, 2, 0, 34, 34, 92, 92, 1, 0, 48, 57, 3, + 0, 48, 57, 65, 70, 97, 102, 3, 0, 65, 90, 95, 95, 97, 122, 4, 0, 48, 57, + 65, 90, 95, 95, 97, 122, 4, 0, 10, 10, 13, 13, 92, 92, 96, 96, 3, 0, 9, + 10, 12, 13, 32, 32, 1, 0, 33, 33, 2, 0, 10, 10, 13, 13, 3595, 0, 53, 1, + 0, 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, + 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, + 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, + 0, 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, + 0, 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, + 0, 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, + 0, 0, 0, 0, 101, 1, 0, 0, 0, 0, 103, 1, 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, + 107, 1, 0, 0, 0, 0, 109, 1, 0, 0, 0, 0, 111, 1, 0, 0, 0, 0, 113, 1, 0, + 0, 0, 0, 115, 1, 0, 0, 0, 0, 117, 1, 0, 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, + 1, 0, 0, 0, 0, 123, 1, 0, 0, 0, 0, 125, 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, + 0, 129, 1, 0, 0, 0, 0, 131, 1, 0, 0, 0, 0, 133, 1, 0, 0, 0, 0, 135, 1, + 0, 0, 0, 0, 137, 1, 0, 0, 0, 0, 165, 1, 0, 0, 0, 0, 167, 1, 0, 0, 0, 0, + 169, 1, 0, 0, 0, 0, 171, 1, 0, 0, 0, 0, 173, 1, 0, 0, 0, 0, 175, 1, 0, + 0, 0, 0, 177, 1, 0, 0, 0, 0, 179, 1, 0, 0, 0, 0, 181, 1, 0, 0, 0, 0, 183, + 1, 0, 0, 0, 0, 185, 1, 0, 0, 0, 0, 187, 1, 0, 0, 0, 0, 197, 1, 0, 0, 0, + 0, 199, 1, 0, 0, 0, 0, 201, 1, 0, 0, 0, 0, 203, 1, 0, 0, 0, 0, 205, 1, + 0, 0, 0, 0, 207, 1, 0, 0, 0, 0, 209, 1, 0, 0, 0, 0, 211, 1, 0, 0, 0, 0, + 213, 1, 0, 0, 0, 0, 215, 1, 0, 0, 0, 0, 217, 1, 0, 0, 0, 0, 219, 1, 0, + 0, 0, 0, 221, 1, 0, 0, 0, 0, 223, 1, 0, 0, 0, 0, 225, 1, 0, 0, 0, 0, 227, + 1, 0, 0, 0, 0, 229, 1, 0, 0, 0, 0, 231, 1, 0, 0, 0, 0, 233, 1, 0, 0, 0, + 0, 235, 1, 0, 0, 0, 0, 237, 1, 0, 0, 0, 0, 239, 1, 0, 0, 0, 0, 241, 1, + 0, 0, 0, 0, 243, 1, 0, 0, 0, 0, 245, 1, 0, 0, 0, 0, 247, 1, 0, 0, 0, 0, + 249, 1, 0, 0, 0, 0, 251, 1, 0, 0, 0, 0, 253, 1, 0, 0, 0, 0, 255, 1, 0, + 0, 0, 0, 257, 1, 0, 0, 0, 0, 259, 1, 0, 0, 0, 0, 261, 1, 0, 0, 0, 0, 263, + 1, 0, 0, 0, 0, 265, 1, 0, 0, 0, 0, 267, 1, 0, 0, 0, 0, 269, 1, 0, 0, 0, + 0, 271, 1, 0, 0, 0, 0, 273, 1, 0, 0, 0, 0, 275, 1, 0, 0, 0, 0, 277, 1, + 0, 0, 0, 0, 279, 1, 0, 0, 0, 0, 281, 1, 0, 0, 0, 0, 283, 1, 0, 0, 0, 0, + 285, 1, 0, 0, 0, 0, 287, 1, 0, 0, 0, 0, 289, 1, 0, 0, 0, 0, 291, 1, 0, + 0, 0, 0, 293, 1, 0, 0, 0, 0, 295, 1, 0, 0, 0, 0, 297, 1, 0, 0, 0, 0, 299, + 1, 0, 0, 0, 0, 301, 1, 0, 0, 0, 0, 303, 1, 0, 0, 0, 0, 305, 1, 0, 0, 0, + 0, 307, 1, 0, 0, 0, 0, 309, 1, 0, 0, 0, 0, 311, 1, 0, 0, 0, 0, 313, 1, + 0, 0, 0, 0, 315, 1, 0, 0, 0, 0, 317, 1, 0, 0, 0, 0, 319, 1, 0, 0, 0, 0, + 321, 1, 0, 0, 0, 0, 323, 1, 0, 0, 0, 0, 325, 1, 0, 0, 0, 0, 327, 1, 0, + 0, 0, 0, 329, 1, 0, 0, 0, 0, 331, 1, 0, 0, 0, 0, 333, 1, 0, 0, 0, 0, 335, + 1, 0, 0, 0, 0, 337, 1, 0, 0, 0, 0, 339, 1, 0, 0, 0, 0, 341, 1, 0, 0, 0, + 0, 343, 1, 0, 0, 0, 0, 345, 1, 0, 0, 0, 0, 347, 1, 0, 0, 0, 0, 349, 1, + 0, 0, 0, 0, 351, 1, 0, 0, 0, 0, 353, 1, 0, 0, 0, 0, 355, 1, 0, 0, 0, 0, + 357, 1, 0, 0, 0, 0, 359, 1, 0, 0, 0, 0, 361, 1, 0, 0, 0, 0, 363, 1, 0, + 0, 0, 0, 365, 1, 0, 0, 0, 0, 367, 1, 0, 0, 0, 0, 369, 1, 0, 0, 0, 0, 371, + 1, 0, 0, 0, 0, 373, 1, 0, 0, 0, 0, 375, 1, 0, 0, 0, 0, 377, 1, 0, 0, 0, + 0, 379, 1, 0, 0, 0, 0, 381, 1, 0, 0, 0, 0, 383, 1, 0, 0, 0, 0, 385, 1, + 0, 0, 0, 0, 387, 1, 0, 0, 0, 0, 389, 1, 0, 0, 0, 0, 391, 1, 0, 0, 0, 0, + 393, 1, 0, 0, 0, 0, 395, 1, 0, 0, 0, 0, 397, 1, 0, 0, 0, 0, 399, 1, 0, + 0, 0, 0, 401, 1, 0, 0, 0, 0, 403, 1, 0, 0, 0, 0, 405, 1, 0, 0, 0, 0, 407, + 1, 0, 0, 0, 0, 409, 1, 0, 0, 0, 0, 411, 1, 0, 0, 0, 0, 413, 1, 0, 0, 0, + 0, 415, 1, 0, 0, 0, 0, 417, 1, 0, 0, 0, 0, 419, 1, 0, 0, 0, 0, 421, 1, + 0, 0, 0, 0, 423, 1, 0, 0, 0, 0, 425, 1, 0, 0, 0, 0, 427, 1, 0, 0, 0, 0, + 429, 1, 0, 0, 0, 0, 431, 1, 0, 0, 0, 0, 433, 1, 0, 0, 0, 0, 435, 1, 0, + 0, 0, 0, 437, 1, 0, 0, 0, 0, 439, 1, 0, 0, 0, 0, 441, 1, 0, 0, 0, 0, 443, + 1, 0, 0, 0, 0, 445, 1, 0, 0, 0, 0, 447, 1, 0, 0, 0, 0, 449, 1, 0, 0, 0, + 0, 451, 1, 0, 0, 0, 0, 453, 1, 0, 0, 0, 0, 455, 1, 0, 0, 0, 0, 457, 1, + 0, 0, 0, 0, 459, 1, 0, 0, 0, 0, 461, 1, 0, 0, 0, 0, 463, 1, 0, 0, 0, 0, + 465, 1, 0, 0, 0, 0, 467, 1, 0, 0, 0, 0, 469, 1, 0, 0, 0, 0, 471, 1, 0, + 0, 0, 0, 473, 1, 0, 0, 0, 0, 475, 1, 0, 0, 0, 0, 477, 1, 0, 0, 0, 0, 479, + 1, 0, 0, 0, 0, 481, 1, 0, 0, 0, 0, 483, 1, 0, 0, 0, 0, 485, 1, 0, 0, 0, + 0, 487, 1, 0, 0, 0, 0, 489, 1, 0, 0, 0, 0, 491, 1, 0, 0, 0, 0, 493, 1, + 0, 0, 0, 0, 495, 1, 0, 0, 0, 0, 497, 1, 0, 0, 0, 0, 499, 1, 0, 0, 0, 0, + 501, 1, 0, 0, 0, 0, 503, 1, 0, 0, 0, 0, 505, 1, 0, 0, 0, 0, 507, 1, 0, + 0, 0, 0, 509, 1, 0, 0, 0, 0, 511, 1, 0, 0, 0, 0, 513, 1, 0, 0, 0, 0, 515, + 1, 0, 0, 0, 0, 517, 1, 0, 0, 0, 0, 519, 1, 0, 0, 0, 0, 521, 1, 0, 0, 0, + 0, 523, 1, 0, 0, 0, 0, 525, 1, 0, 0, 0, 0, 527, 1, 0, 0, 0, 0, 529, 1, + 0, 0, 0, 0, 531, 1, 0, 0, 0, 0, 533, 1, 0, 0, 0, 0, 535, 1, 0, 0, 0, 0, + 537, 1, 0, 0, 0, 0, 539, 1, 0, 0, 0, 0, 541, 1, 0, 0, 0, 0, 543, 1, 0, + 0, 0, 0, 545, 1, 0, 0, 0, 0, 547, 1, 0, 0, 0, 0, 549, 1, 0, 0, 0, 0, 551, + 1, 0, 0, 0, 0, 553, 1, 0, 0, 0, 0, 555, 1, 0, 0, 0, 0, 557, 1, 0, 0, 0, + 0, 559, 1, 0, 0, 0, 0, 561, 1, 0, 0, 0, 0, 563, 1, 0, 0, 0, 0, 565, 1, + 0, 0, 0, 0, 567, 1, 0, 0, 0, 0, 569, 1, 0, 0, 0, 0, 571, 1, 0, 0, 0, 0, + 573, 1, 0, 0, 0, 0, 575, 1, 0, 0, 0, 0, 577, 1, 0, 0, 0, 0, 579, 1, 0, + 0, 0, 0, 581, 1, 0, 0, 0, 0, 583, 1, 0, 0, 0, 0, 585, 1, 0, 0, 0, 0, 587, + 1, 0, 0, 0, 0, 589, 1, 0, 0, 0, 0, 591, 1, 0, 0, 0, 0, 593, 1, 0, 0, 0, + 0, 595, 1, 0, 0, 0, 0, 597, 1, 0, 0, 0, 0, 599, 1, 0, 0, 0, 0, 601, 1, + 0, 0, 0, 0, 603, 1, 0, 0, 0, 0, 605, 1, 0, 0, 0, 0, 607, 1, 0, 0, 0, 0, + 609, 1, 0, 0, 0, 0, 611, 1, 0, 0, 0, 0, 613, 1, 0, 0, 0, 0, 615, 1, 0, + 0, 0, 0, 617, 1, 0, 0, 0, 0, 619, 1, 0, 0, 0, 0, 621, 1, 0, 0, 0, 0, 623, + 1, 0, 0, 0, 0, 625, 1, 0, 0, 0, 0, 627, 1, 0, 0, 0, 0, 629, 1, 0, 0, 0, + 0, 631, 1, 0, 0, 0, 0, 633, 1, 0, 0, 0, 0, 635, 1, 0, 0, 0, 0, 637, 1, + 0, 0, 0, 0, 639, 1, 0, 0, 0, 0, 641, 1, 0, 0, 0, 0, 643, 1, 0, 0, 0, 0, + 645, 1, 0, 0, 0, 0, 647, 1, 0, 0, 0, 0, 649, 1, 0, 0, 0, 0, 651, 1, 0, + 0, 0, 0, 653, 1, 0, 0, 0, 0, 655, 1, 0, 0, 0, 0, 657, 1, 0, 0, 0, 0, 659, + 1, 0, 0, 0, 0, 661, 1, 0, 0, 0, 0, 663, 1, 0, 0, 0, 0, 665, 1, 0, 0, 0, + 0, 667, 1, 0, 0, 0, 0, 669, 1, 0, 0, 0, 0, 671, 1, 0, 0, 0, 0, 673, 1, + 0, 0, 0, 0, 675, 1, 0, 0, 0, 0, 677, 1, 0, 0, 0, 0, 679, 1, 0, 0, 0, 0, + 681, 1, 0, 0, 0, 0, 683, 1, 0, 0, 0, 0, 685, 1, 0, 0, 0, 0, 687, 1, 0, + 0, 0, 0, 689, 1, 0, 0, 0, 0, 691, 1, 0, 0, 0, 0, 693, 1, 0, 0, 0, 0, 695, + 1, 0, 0, 0, 0, 697, 1, 0, 0, 0, 0, 699, 1, 0, 0, 0, 0, 701, 1, 0, 0, 0, + 0, 703, 1, 0, 0, 0, 0, 705, 1, 0, 0, 0, 0, 707, 1, 0, 0, 0, 0, 709, 1, + 0, 0, 0, 0, 711, 1, 0, 0, 0, 0, 713, 1, 0, 0, 0, 0, 715, 1, 0, 0, 0, 0, + 717, 1, 0, 0, 0, 0, 719, 1, 0, 0, 0, 0, 721, 1, 0, 0, 0, 0, 723, 1, 0, + 0, 0, 0, 725, 1, 0, 0, 0, 0, 727, 1, 0, 0, 0, 0, 729, 1, 0, 0, 0, 0, 731, + 1, 0, 0, 0, 0, 733, 1, 0, 0, 0, 0, 735, 1, 0, 0, 0, 0, 737, 1, 0, 0, 0, + 0, 739, 1, 0, 0, 0, 0, 741, 1, 0, 0, 0, 0, 743, 1, 0, 0, 0, 0, 745, 1, + 0, 0, 0, 0, 747, 1, 0, 0, 0, 0, 749, 1, 0, 0, 0, 0, 751, 1, 0, 0, 0, 0, + 753, 1, 0, 0, 0, 0, 755, 1, 0, 0, 0, 0, 757, 1, 0, 0, 0, 0, 759, 1, 0, + 0, 0, 0, 761, 1, 0, 0, 0, 0, 763, 1, 0, 0, 0, 0, 765, 1, 0, 0, 0, 0, 767, + 1, 0, 0, 0, 0, 769, 1, 0, 0, 0, 0, 771, 1, 0, 0, 0, 0, 773, 1, 0, 0, 0, + 0, 775, 1, 0, 0, 0, 0, 777, 1, 0, 0, 0, 0, 779, 1, 0, 0, 0, 0, 781, 1, + 0, 0, 0, 0, 783, 1, 0, 0, 0, 0, 785, 1, 0, 0, 0, 0, 787, 1, 0, 0, 0, 0, + 789, 1, 0, 0, 0, 0, 791, 1, 0, 0, 0, 0, 793, 1, 0, 0, 0, 0, 795, 1, 0, + 0, 0, 0, 797, 1, 0, 0, 0, 0, 799, 1, 0, 0, 0, 0, 801, 1, 0, 0, 0, 0, 803, + 1, 0, 0, 0, 0, 805, 1, 0, 0, 0, 0, 807, 1, 0, 0, 0, 0, 809, 1, 0, 0, 0, + 0, 811, 1, 0, 0, 0, 0, 821, 1, 0, 0, 0, 0, 823, 1, 0, 0, 0, 0, 825, 1, + 0, 0, 0, 0, 833, 1, 0, 0, 0, 1, 835, 1, 0, 0, 0, 3, 837, 1, 0, 0, 0, 5, + 839, 1, 0, 0, 0, 7, 841, 1, 0, 0, 0, 9, 843, 1, 0, 0, 0, 11, 845, 1, 0, + 0, 0, 13, 847, 1, 0, 0, 0, 15, 849, 1, 0, 0, 0, 17, 851, 1, 0, 0, 0, 19, + 853, 1, 0, 0, 0, 21, 855, 1, 0, 0, 0, 23, 857, 1, 0, 0, 0, 25, 859, 1, + 0, 0, 0, 27, 861, 1, 0, 0, 0, 29, 863, 1, 0, 0, 0, 31, 865, 1, 0, 0, 0, + 33, 867, 1, 0, 0, 0, 35, 869, 1, 0, 0, 0, 37, 871, 1, 0, 0, 0, 39, 873, + 1, 0, 0, 0, 41, 875, 1, 0, 0, 0, 43, 877, 1, 0, 0, 0, 45, 879, 1, 0, 0, + 0, 47, 881, 1, 0, 0, 0, 49, 883, 1, 0, 0, 0, 51, 885, 1, 0, 0, 0, 53, 887, + 1, 0, 0, 0, 55, 889, 1, 0, 0, 0, 57, 892, 1, 0, 0, 0, 59, 895, 1, 0, 0, + 0, 61, 897, 1, 0, 0, 0, 63, 900, 1, 0, 0, 0, 65, 902, 1, 0, 0, 0, 67, 905, + 1, 0, 0, 0, 69, 908, 1, 0, 0, 0, 71, 911, 1, 0, 0, 0, 73, 913, 1, 0, 0, + 0, 75, 915, 1, 0, 0, 0, 77, 917, 1, 0, 0, 0, 79, 919, 1, 0, 0, 0, 81, 921, + 1, 0, 0, 0, 83, 923, 1, 0, 0, 0, 85, 925, 1, 0, 0, 0, 87, 927, 1, 0, 0, + 0, 89, 929, 1, 0, 0, 0, 91, 931, 1, 0, 0, 0, 93, 933, 1, 0, 0, 0, 95, 935, + 1, 0, 0, 0, 97, 937, 1, 0, 0, 0, 99, 939, 1, 0, 0, 0, 101, 941, 1, 0, 0, + 0, 103, 943, 1, 0, 0, 0, 105, 945, 1, 0, 0, 0, 107, 947, 1, 0, 0, 0, 109, + 949, 1, 0, 0, 0, 111, 953, 1, 0, 0, 0, 113, 955, 1, 0, 0, 0, 115, 959, + 1, 0, 0, 0, 117, 961, 1, 0, 0, 0, 119, 963, 1, 0, 0, 0, 121, 965, 1, 0, + 0, 0, 123, 968, 1, 0, 0, 0, 125, 971, 1, 0, 0, 0, 127, 974, 1, 0, 0, 0, + 129, 977, 1, 0, 0, 0, 131, 980, 1, 0, 0, 0, 133, 983, 1, 0, 0, 0, 135, + 985, 1, 0, 0, 0, 137, 987, 1, 0, 0, 0, 139, 999, 1, 0, 0, 0, 141, 1001, + 1, 0, 0, 0, 143, 1003, 1, 0, 0, 0, 145, 1005, 1, 0, 0, 0, 147, 1007, 1, + 0, 0, 0, 149, 1009, 1, 0, 0, 0, 151, 1017, 1, 0, 0, 0, 153, 1020, 1, 0, + 0, 0, 155, 1028, 1, 0, 0, 0, 157, 1031, 1, 0, 0, 0, 159, 1047, 1, 0, 0, + 0, 161, 1050, 1, 0, 0, 0, 163, 1066, 1, 0, 0, 0, 165, 1070, 1, 0, 0, 0, + 167, 1085, 1, 0, 0, 0, 169, 1095, 1, 0, 0, 0, 171, 1099, 1, 0, 0, 0, 173, + 1101, 1, 0, 0, 0, 175, 1106, 1, 0, 0, 0, 177, 1111, 1, 0, 0, 0, 179, 1116, + 1, 0, 0, 0, 181, 1127, 1, 0, 0, 0, 183, 1139, 1, 0, 0, 0, 185, 1187, 1, + 0, 0, 0, 187, 1191, 1, 0, 0, 0, 189, 1193, 1, 0, 0, 0, 191, 1195, 1, 0, + 0, 0, 193, 1198, 1, 0, 0, 0, 195, 1202, 1, 0, 0, 0, 197, 1210, 1, 0, 0, + 0, 199, 1216, 1, 0, 0, 0, 201, 1220, 1, 0, 0, 0, 203, 1223, 1, 0, 0, 0, + 205, 1227, 1, 0, 0, 0, 207, 1230, 1, 0, 0, 0, 209, 1236, 1, 0, 0, 0, 211, + 1241, 1, 0, 0, 0, 213, 1247, 1, 0, 0, 0, 215, 1252, 1, 0, 0, 0, 217, 1273, + 1, 0, 0, 0, 219, 1282, 1, 0, 0, 0, 221, 1290, 1, 0, 0, 0, 223, 1297, 1, + 0, 0, 0, 225, 1305, 1, 0, 0, 0, 227, 1309, 1, 0, 0, 0, 229, 1314, 1, 0, + 0, 0, 231, 1319, 1, 0, 0, 0, 233, 1322, 1, 0, 0, 0, 235, 1330, 1, 0, 0, + 0, 237, 1336, 1, 0, 0, 0, 239, 1346, 1, 0, 0, 0, 241, 1351, 1, 0, 0, 0, + 243, 1357, 1, 0, 0, 0, 245, 1380, 1, 0, 0, 0, 247, 1385, 1, 0, 0, 0, 249, + 1391, 1, 0, 0, 0, 251, 1394, 1, 0, 0, 0, 253, 1401, 1, 0, 0, 0, 255, 1404, + 1, 0, 0, 0, 257, 1412, 1, 0, 0, 0, 259, 1418, 1, 0, 0, 0, 261, 1424, 1, + 0, 0, 0, 263, 1432, 1, 0, 0, 0, 265, 1438, 1, 0, 0, 0, 267, 1458, 1, 0, + 0, 0, 269, 1464, 1, 0, 0, 0, 271, 1474, 1, 0, 0, 0, 273, 1482, 1, 0, 0, + 0, 275, 1490, 1, 0, 0, 0, 277, 1497, 1, 0, 0, 0, 279, 1504, 1, 0, 0, 0, + 281, 1511, 1, 0, 0, 0, 283, 1523, 1, 0, 0, 0, 285, 1535, 1, 0, 0, 0, 287, + 1541, 1, 0, 0, 0, 289, 1548, 1, 0, 0, 0, 291, 1554, 1, 0, 0, 0, 293, 1560, + 1, 0, 0, 0, 295, 1565, 1, 0, 0, 0, 297, 1570, 1, 0, 0, 0, 299, 1576, 1, + 0, 0, 0, 301, 1584, 1, 0, 0, 0, 303, 1592, 1, 0, 0, 0, 305, 1603, 1, 0, + 0, 0, 307, 1614, 1, 0, 0, 0, 309, 1618, 1, 0, 0, 0, 311, 1622, 1, 0, 0, + 0, 313, 1625, 1, 0, 0, 0, 315, 1630, 1, 0, 0, 0, 317, 1635, 1, 0, 0, 0, + 319, 1640, 1, 0, 0, 0, 321, 1649, 1, 0, 0, 0, 323, 1659, 1, 0, 0, 0, 325, + 1665, 1, 0, 0, 0, 327, 1674, 1, 0, 0, 0, 329, 1681, 1, 0, 0, 0, 331, 1687, + 1, 0, 0, 0, 333, 1694, 1, 0, 0, 0, 335, 1701, 1, 0, 0, 0, 337, 1711, 1, + 0, 0, 0, 339, 1715, 1, 0, 0, 0, 341, 1721, 1, 0, 0, 0, 343, 1728, 1, 0, + 0, 0, 345, 1736, 1, 0, 0, 0, 347, 1743, 1, 0, 0, 0, 349, 1747, 1, 0, 0, + 0, 351, 1754, 1, 0, 0, 0, 353, 1760, 1, 0, 0, 0, 355, 1766, 1, 0, 0, 0, + 357, 1772, 1, 0, 0, 0, 359, 1777, 1, 0, 0, 0, 361, 1785, 1, 0, 0, 0, 363, + 1791, 1, 0, 0, 0, 365, 1799, 1, 0, 0, 0, 367, 1805, 1, 0, 0, 0, 369, 1810, + 1, 0, 0, 0, 371, 1818, 1, 0, 0, 0, 373, 1825, 1, 0, 0, 0, 375, 1833, 1, + 0, 0, 0, 377, 1840, 1, 0, 0, 0, 379, 1851, 1, 0, 0, 0, 381, 1860, 1, 0, + 0, 0, 383, 1871, 1, 0, 0, 0, 385, 1880, 1, 0, 0, 0, 387, 1894, 1, 0, 0, + 0, 389, 1900, 1, 0, 0, 0, 391, 1905, 1, 0, 0, 0, 393, 1914, 1, 0, 0, 0, + 395, 1922, 1, 0, 0, 0, 397, 1930, 1, 0, 0, 0, 399, 1937, 1, 0, 0, 0, 401, + 1946, 1, 0, 0, 0, 403, 1952, 1, 0, 0, 0, 405, 1961, 1, 0, 0, 0, 407, 1975, + 1, 0, 0, 0, 409, 1978, 1, 0, 0, 0, 411, 1983, 1, 0, 0, 0, 413, 1990, 1, + 0, 0, 0, 415, 1999, 1, 0, 0, 0, 417, 2005, 1, 0, 0, 0, 419, 2015, 1, 0, + 0, 0, 421, 2023, 1, 0, 0, 0, 423, 2031, 1, 0, 0, 0, 425, 2038, 1, 0, 0, + 0, 427, 2045, 1, 0, 0, 0, 429, 2054, 1, 0, 0, 0, 431, 2060, 1, 0, 0, 0, + 433, 2067, 1, 0, 0, 0, 435, 2072, 1, 0, 0, 0, 437, 2078, 1, 0, 0, 0, 439, + 2086, 1, 0, 0, 0, 441, 2093, 1, 0, 0, 0, 443, 2102, 1, 0, 0, 0, 445, 2112, + 1, 0, 0, 0, 447, 2118, 1, 0, 0, 0, 449, 2129, 1, 0, 0, 0, 451, 2136, 1, + 0, 0, 0, 453, 2145, 1, 0, 0, 0, 455, 2155, 1, 0, 0, 0, 457, 2165, 1, 0, + 0, 0, 459, 2172, 1, 0, 0, 0, 461, 2182, 1, 0, 0, 0, 463, 2188, 1, 0, 0, + 0, 465, 2194, 1, 0, 0, 0, 467, 2200, 1, 0, 0, 0, 469, 2207, 1, 0, 0, 0, + 471, 2215, 1, 0, 0, 0, 473, 2225, 1, 0, 0, 0, 475, 2233, 1, 0, 0, 0, 477, + 2237, 1, 0, 0, 0, 479, 2246, 1, 0, 0, 0, 481, 2251, 1, 0, 0, 0, 483, 2257, + 1, 0, 0, 0, 485, 2263, 1, 0, 0, 0, 487, 2268, 1, 0, 0, 0, 489, 2273, 1, + 0, 0, 0, 491, 2279, 1, 0, 0, 0, 493, 2283, 1, 0, 0, 0, 495, 2289, 1, 0, + 0, 0, 497, 2320, 1, 0, 0, 0, 499, 2328, 1, 0, 0, 0, 501, 2341, 1, 0, 0, + 0, 503, 2345, 1, 0, 0, 0, 505, 2354, 1, 0, 0, 0, 507, 2363, 1, 0, 0, 0, + 509, 2371, 1, 0, 0, 0, 511, 2380, 1, 0, 0, 0, 513, 2384, 1, 0, 0, 0, 515, + 2393, 1, 0, 0, 0, 517, 2399, 1, 0, 0, 0, 519, 2406, 1, 0, 0, 0, 521, 2411, + 1, 0, 0, 0, 523, 2415, 1, 0, 0, 0, 525, 2422, 1, 0, 0, 0, 527, 2432, 1, + 0, 0, 0, 529, 2443, 1, 0, 0, 0, 531, 2451, 1, 0, 0, 0, 533, 2460, 1, 0, + 0, 0, 535, 2467, 1, 0, 0, 0, 537, 2475, 1, 0, 0, 0, 539, 2483, 1, 0, 0, + 0, 541, 2493, 1, 0, 0, 0, 543, 2504, 1, 0, 0, 0, 545, 2514, 1, 0, 0, 0, + 547, 2522, 1, 0, 0, 0, 549, 2529, 1, 0, 0, 0, 551, 2535, 1, 0, 0, 0, 553, + 2540, 1, 0, 0, 0, 555, 2551, 1, 0, 0, 0, 557, 2558, 1, 0, 0, 0, 559, 2565, + 1, 0, 0, 0, 561, 2572, 1, 0, 0, 0, 563, 2579, 1, 0, 0, 0, 565, 2590, 1, + 0, 0, 0, 567, 2605, 1, 0, 0, 0, 569, 2613, 1, 0, 0, 0, 571, 2620, 1, 0, + 0, 0, 573, 2629, 1, 0, 0, 0, 575, 2641, 1, 0, 0, 0, 577, 2649, 1, 0, 0, + 0, 579, 2656, 1, 0, 0, 0, 581, 2663, 1, 0, 0, 0, 583, 2672, 1, 0, 0, 0, + 585, 2676, 1, 0, 0, 0, 587, 2680, 1, 0, 0, 0, 589, 2690, 1, 0, 0, 0, 591, + 2697, 1, 0, 0, 0, 593, 2704, 1, 0, 0, 0, 595, 2713, 1, 0, 0, 0, 597, 2722, + 1, 0, 0, 0, 599, 2727, 1, 0, 0, 0, 601, 2731, 1, 0, 0, 0, 603, 2736, 1, + 0, 0, 0, 605, 2745, 1, 0, 0, 0, 607, 2752, 1, 0, 0, 0, 609, 2756, 1, 0, + 0, 0, 611, 2763, 1, 0, 0, 0, 613, 2769, 1, 0, 0, 0, 615, 2785, 1, 0, 0, + 0, 617, 2792, 1, 0, 0, 0, 619, 2800, 1, 0, 0, 0, 621, 2807, 1, 0, 0, 0, + 623, 2813, 1, 0, 0, 0, 625, 2820, 1, 0, 0, 0, 627, 2827, 1, 0, 0, 0, 629, + 2832, 1, 0, 0, 0, 631, 2842, 1, 0, 0, 0, 633, 2854, 1, 0, 0, 0, 635, 2864, + 1, 0, 0, 0, 637, 2873, 1, 0, 0, 0, 639, 2878, 1, 0, 0, 0, 641, 2885, 1, + 0, 0, 0, 643, 2892, 1, 0, 0, 0, 645, 2900, 1, 0, 0, 0, 647, 2906, 1, 0, + 0, 0, 649, 2913, 1, 0, 0, 0, 651, 2920, 1, 0, 0, 0, 653, 2927, 1, 0, 0, + 0, 655, 2932, 1, 0, 0, 0, 657, 2938, 1, 0, 0, 0, 659, 2947, 1, 0, 0, 0, + 661, 2954, 1, 0, 0, 0, 663, 2960, 1, 0, 0, 0, 665, 2966, 1, 0, 0, 0, 667, + 2971, 1, 0, 0, 0, 669, 2982, 1, 0, 0, 0, 671, 2993, 1, 0, 0, 0, 673, 3007, + 1, 0, 0, 0, 675, 3014, 1, 0, 0, 0, 677, 3018, 1, 0, 0, 0, 679, 3022, 1, + 0, 0, 0, 681, 3027, 1, 0, 0, 0, 683, 3032, 1, 0, 0, 0, 685, 3037, 1, 0, + 0, 0, 687, 3042, 1, 0, 0, 0, 689, 3047, 1, 0, 0, 0, 691, 3055, 1, 0, 0, + 0, 693, 3063, 1, 0, 0, 0, 695, 3066, 1, 0, 0, 0, 697, 3075, 1, 0, 0, 0, + 699, 3082, 1, 0, 0, 0, 701, 3088, 1, 0, 0, 0, 703, 3095, 1, 0, 0, 0, 705, + 3100, 1, 0, 0, 0, 707, 3105, 1, 0, 0, 0, 709, 3111, 1, 0, 0, 0, 711, 3121, + 1, 0, 0, 0, 713, 3128, 1, 0, 0, 0, 715, 3136, 1, 0, 0, 0, 717, 3141, 1, + 0, 0, 0, 719, 3146, 1, 0, 0, 0, 721, 3154, 1, 0, 0, 0, 723, 3164, 1, 0, + 0, 0, 725, 3172, 1, 0, 0, 0, 727, 3182, 1, 0, 0, 0, 729, 3192, 1, 0, 0, + 0, 731, 3200, 1, 0, 0, 0, 733, 3208, 1, 0, 0, 0, 735, 3216, 1, 0, 0, 0, + 737, 3222, 1, 0, 0, 0, 739, 3238, 1, 0, 0, 0, 741, 3245, 1, 0, 0, 0, 743, + 3252, 1, 0, 0, 0, 745, 3258, 1, 0, 0, 0, 747, 3265, 1, 0, 0, 0, 749, 3268, + 1, 0, 0, 0, 751, 3275, 1, 0, 0, 0, 753, 3279, 1, 0, 0, 0, 755, 3284, 1, + 0, 0, 0, 757, 3289, 1, 0, 0, 0, 759, 3292, 1, 0, 0, 0, 761, 3295, 1, 0, + 0, 0, 763, 3300, 1, 0, 0, 0, 765, 3321, 1, 0, 0, 0, 767, 3330, 1, 0, 0, + 0, 769, 3338, 1, 0, 0, 0, 771, 3344, 1, 0, 0, 0, 773, 3351, 1, 0, 0, 0, + 775, 3356, 1, 0, 0, 0, 777, 3368, 1, 0, 0, 0, 779, 3377, 1, 0, 0, 0, 781, + 3383, 1, 0, 0, 0, 783, 3388, 1, 0, 0, 0, 785, 3399, 1, 0, 0, 0, 787, 3405, + 1, 0, 0, 0, 789, 3410, 1, 0, 0, 0, 791, 3415, 1, 0, 0, 0, 793, 3425, 1, + 0, 0, 0, 795, 3436, 1, 0, 0, 0, 797, 3441, 1, 0, 0, 0, 799, 3450, 1, 0, + 0, 0, 801, 3455, 1, 0, 0, 0, 803, 3461, 1, 0, 0, 0, 805, 3466, 1, 0, 0, + 0, 807, 3472, 1, 0, 0, 0, 809, 3480, 1, 0, 0, 0, 811, 3489, 1, 0, 0, 0, + 813, 3493, 1, 0, 0, 0, 815, 3499, 1, 0, 0, 0, 817, 3506, 1, 0, 0, 0, 819, + 3514, 1, 0, 0, 0, 821, 3519, 1, 0, 0, 0, 823, 3521, 1, 0, 0, 0, 825, 3523, + 1, 0, 0, 0, 827, 3543, 1, 0, 0, 0, 829, 3545, 1, 0, 0, 0, 831, 3559, 1, + 0, 0, 0, 833, 3574, 1, 0, 0, 0, 835, 836, 7, 0, 0, 0, 836, 2, 1, 0, 0, + 0, 837, 838, 7, 1, 0, 0, 838, 4, 1, 0, 0, 0, 839, 840, 7, 2, 0, 0, 840, + 6, 1, 0, 0, 0, 841, 842, 7, 3, 0, 0, 842, 8, 1, 0, 0, 0, 843, 844, 7, 4, + 0, 0, 844, 10, 1, 0, 0, 0, 845, 846, 7, 5, 0, 0, 846, 12, 1, 0, 0, 0, 847, + 848, 7, 6, 0, 0, 848, 14, 1, 0, 0, 0, 849, 850, 7, 7, 0, 0, 850, 16, 1, + 0, 0, 0, 851, 852, 7, 8, 0, 0, 852, 18, 1, 0, 0, 0, 853, 854, 7, 9, 0, + 0, 854, 20, 1, 0, 0, 0, 855, 856, 7, 10, 0, 0, 856, 22, 1, 0, 0, 0, 857, + 858, 7, 11, 0, 0, 858, 24, 1, 0, 0, 0, 859, 860, 7, 12, 0, 0, 860, 26, + 1, 0, 0, 0, 861, 862, 7, 13, 0, 0, 862, 28, 1, 0, 0, 0, 863, 864, 7, 14, + 0, 0, 864, 30, 1, 0, 0, 0, 865, 866, 7, 15, 0, 0, 866, 32, 1, 0, 0, 0, + 867, 868, 7, 16, 0, 0, 868, 34, 1, 0, 0, 0, 869, 870, 7, 17, 0, 0, 870, + 36, 1, 0, 0, 0, 871, 872, 7, 18, 0, 0, 872, 38, 1, 0, 0, 0, 873, 874, 7, + 19, 0, 0, 874, 40, 1, 0, 0, 0, 875, 876, 7, 20, 0, 0, 876, 42, 1, 0, 0, + 0, 877, 878, 7, 21, 0, 0, 878, 44, 1, 0, 0, 0, 879, 880, 7, 22, 0, 0, 880, + 46, 1, 0, 0, 0, 881, 882, 7, 23, 0, 0, 882, 48, 1, 0, 0, 0, 883, 884, 7, + 24, 0, 0, 884, 50, 1, 0, 0, 0, 885, 886, 7, 25, 0, 0, 886, 52, 1, 0, 0, + 0, 887, 888, 5, 61, 0, 0, 888, 54, 1, 0, 0, 0, 889, 890, 5, 33, 0, 0, 890, + 891, 5, 61, 0, 0, 891, 56, 1, 0, 0, 0, 892, 893, 5, 60, 0, 0, 893, 894, + 5, 62, 0, 0, 894, 58, 1, 0, 0, 0, 895, 896, 5, 60, 0, 0, 896, 60, 1, 0, + 0, 0, 897, 898, 5, 60, 0, 0, 898, 899, 5, 61, 0, 0, 899, 62, 1, 0, 0, 0, + 900, 901, 5, 62, 0, 0, 901, 64, 1, 0, 0, 0, 902, 903, 5, 62, 0, 0, 903, + 904, 5, 61, 0, 0, 904, 66, 1, 0, 0, 0, 905, 906, 5, 60, 0, 0, 906, 907, + 5, 60, 0, 0, 907, 68, 1, 0, 0, 0, 908, 909, 5, 62, 0, 0, 909, 910, 5, 62, + 0, 0, 910, 70, 1, 0, 0, 0, 911, 912, 5, 43, 0, 0, 912, 72, 1, 0, 0, 0, + 913, 914, 5, 45, 0, 0, 914, 74, 1, 0, 0, 0, 915, 916, 5, 42, 0, 0, 916, + 76, 1, 0, 0, 0, 917, 918, 5, 47, 0, 0, 918, 78, 1, 0, 0, 0, 919, 920, 5, + 126, 0, 0, 920, 80, 1, 0, 0, 0, 921, 922, 5, 33, 0, 0, 922, 82, 1, 0, 0, + 0, 923, 924, 5, 37, 0, 0, 924, 84, 1, 0, 0, 0, 925, 926, 5, 44, 0, 0, 926, + 86, 1, 0, 0, 0, 927, 928, 5, 46, 0, 0, 928, 88, 1, 0, 0, 0, 929, 930, 5, + 123, 0, 0, 930, 90, 1, 0, 0, 0, 931, 932, 5, 125, 0, 0, 932, 92, 1, 0, + 0, 0, 933, 934, 5, 40, 0, 0, 934, 94, 1, 0, 0, 0, 935, 936, 5, 41, 0, 0, + 936, 96, 1, 0, 0, 0, 937, 938, 5, 91, 0, 0, 938, 98, 1, 0, 0, 0, 939, 940, + 5, 93, 0, 0, 940, 100, 1, 0, 0, 0, 941, 942, 5, 124, 0, 0, 942, 102, 1, + 0, 0, 0, 943, 944, 5, 58, 0, 0, 944, 104, 1, 0, 0, 0, 945, 946, 5, 59, + 0, 0, 946, 106, 1, 0, 0, 0, 947, 948, 5, 39, 0, 0, 948, 108, 1, 0, 0, 0, + 949, 950, 5, 39, 0, 0, 950, 951, 5, 39, 0, 0, 951, 952, 5, 39, 0, 0, 952, + 110, 1, 0, 0, 0, 953, 954, 5, 34, 0, 0, 954, 112, 1, 0, 0, 0, 955, 956, + 5, 34, 0, 0, 956, 957, 5, 34, 0, 0, 957, 958, 5, 34, 0, 0, 958, 114, 1, + 0, 0, 0, 959, 960, 5, 96, 0, 0, 960, 116, 1, 0, 0, 0, 961, 962, 5, 63, + 0, 0, 962, 118, 1, 0, 0, 0, 963, 964, 5, 64, 0, 0, 964, 120, 1, 0, 0, 0, + 965, 966, 5, 64, 0, 0, 966, 967, 5, 64, 0, 0, 967, 122, 1, 0, 0, 0, 968, + 969, 5, 61, 0, 0, 969, 970, 5, 62, 0, 0, 970, 124, 1, 0, 0, 0, 971, 972, + 5, 45, 0, 0, 972, 973, 5, 62, 0, 0, 973, 126, 1, 0, 0, 0, 974, 975, 5, + 43, 0, 0, 975, 976, 5, 61, 0, 0, 976, 128, 1, 0, 0, 0, 977, 978, 5, 45, + 0, 0, 978, 979, 5, 61, 0, 0, 979, 130, 1, 0, 0, 0, 980, 981, 5, 124, 0, + 0, 981, 982, 5, 62, 0, 0, 982, 132, 1, 0, 0, 0, 983, 984, 5, 94, 0, 0, + 984, 134, 1, 0, 0, 0, 985, 986, 5, 38, 0, 0, 986, 136, 1, 0, 0, 0, 987, + 988, 5, 124, 0, 0, 988, 989, 5, 124, 0, 0, 989, 138, 1, 0, 0, 0, 990, 991, + 5, 92, 0, 0, 991, 1000, 9, 0, 0, 0, 992, 993, 5, 92, 0, 0, 993, 1000, 5, + 10, 0, 0, 994, 995, 5, 92, 0, 0, 995, 1000, 5, 13, 0, 0, 996, 997, 5, 92, + 0, 0, 997, 998, 5, 13, 0, 0, 998, 1000, 5, 10, 0, 0, 999, 990, 1, 0, 0, + 0, 999, 992, 1, 0, 0, 0, 999, 994, 1, 0, 0, 0, 999, 996, 1, 0, 0, 0, 1000, + 140, 1, 0, 0, 0, 1001, 1002, 8, 26, 0, 0, 1002, 142, 1, 0, 0, 0, 1003, + 1004, 8, 27, 0, 0, 1004, 144, 1, 0, 0, 0, 1005, 1006, 8, 28, 0, 0, 1006, + 146, 1, 0, 0, 0, 1007, 1008, 8, 29, 0, 0, 1008, 148, 1, 0, 0, 0, 1009, + 1014, 3, 107, 53, 0, 1010, 1013, 3, 141, 70, 0, 1011, 1013, 3, 139, 69, + 0, 1012, 1010, 1, 0, 0, 0, 1012, 1011, 1, 0, 0, 0, 1013, 1016, 1, 0, 0, + 0, 1014, 1012, 1, 0, 0, 0, 1014, 1015, 1, 0, 0, 0, 1015, 150, 1, 0, 0, + 0, 1016, 1014, 1, 0, 0, 0, 1017, 1018, 3, 149, 74, 0, 1018, 1019, 3, 107, + 53, 0, 1019, 152, 1, 0, 0, 0, 1020, 1025, 3, 111, 55, 0, 1021, 1024, 3, + 143, 71, 0, 1022, 1024, 3, 139, 69, 0, 1023, 1021, 1, 0, 0, 0, 1023, 1022, + 1, 0, 0, 0, 1024, 1027, 1, 0, 0, 0, 1025, 1023, 1, 0, 0, 0, 1025, 1026, + 1, 0, 0, 0, 1026, 154, 1, 0, 0, 0, 1027, 1025, 1, 0, 0, 0, 1028, 1029, + 3, 153, 76, 0, 1029, 1030, 3, 111, 55, 0, 1030, 156, 1, 0, 0, 0, 1031, + 1044, 3, 109, 54, 0, 1032, 1034, 3, 107, 53, 0, 1033, 1035, 3, 107, 53, + 0, 1034, 1033, 1, 0, 0, 0, 1034, 1035, 1, 0, 0, 0, 1035, 1037, 1, 0, 0, + 0, 1036, 1032, 1, 0, 0, 0, 1036, 1037, 1, 0, 0, 0, 1037, 1040, 1, 0, 0, + 0, 1038, 1041, 3, 145, 72, 0, 1039, 1041, 3, 139, 69, 0, 1040, 1038, 1, + 0, 0, 0, 1040, 1039, 1, 0, 0, 0, 1041, 1043, 1, 0, 0, 0, 1042, 1036, 1, + 0, 0, 0, 1043, 1046, 1, 0, 0, 0, 1044, 1042, 1, 0, 0, 0, 1044, 1045, 1, + 0, 0, 0, 1045, 158, 1, 0, 0, 0, 1046, 1044, 1, 0, 0, 0, 1047, 1048, 3, + 157, 78, 0, 1048, 1049, 3, 109, 54, 0, 1049, 160, 1, 0, 0, 0, 1050, 1063, + 3, 113, 56, 0, 1051, 1053, 3, 111, 55, 0, 1052, 1054, 3, 111, 55, 0, 1053, + 1052, 1, 0, 0, 0, 1053, 1054, 1, 0, 0, 0, 1054, 1056, 1, 0, 0, 0, 1055, + 1051, 1, 0, 0, 0, 1055, 1056, 1, 0, 0, 0, 1056, 1059, 1, 0, 0, 0, 1057, + 1060, 3, 147, 73, 0, 1058, 1060, 3, 139, 69, 0, 1059, 1057, 1, 0, 0, 0, + 1059, 1058, 1, 0, 0, 0, 1060, 1062, 1, 0, 0, 0, 1061, 1055, 1, 0, 0, 0, + 1062, 1065, 1, 0, 0, 0, 1063, 1061, 1, 0, 0, 0, 1063, 1064, 1, 0, 0, 0, + 1064, 162, 1, 0, 0, 0, 1065, 1063, 1, 0, 0, 0, 1066, 1067, 3, 161, 80, + 0, 1067, 1068, 3, 113, 56, 0, 1068, 164, 1, 0, 0, 0, 1069, 1071, 3, 35, + 17, 0, 1070, 1069, 1, 0, 0, 0, 1070, 1071, 1, 0, 0, 0, 1071, 1076, 1, 0, + 0, 0, 1072, 1077, 3, 151, 75, 0, 1073, 1077, 3, 155, 77, 0, 1074, 1077, + 3, 159, 79, 0, 1075, 1077, 3, 163, 81, 0, 1076, 1072, 1, 0, 0, 0, 1076, + 1073, 1, 0, 0, 0, 1076, 1074, 1, 0, 0, 0, 1076, 1075, 1, 0, 0, 0, 1077, + 166, 1, 0, 0, 0, 1078, 1086, 3, 3, 1, 0, 1079, 1080, 3, 35, 17, 0, 1080, + 1081, 3, 3, 1, 0, 1081, 1086, 1, 0, 0, 0, 1082, 1083, 3, 3, 1, 0, 1083, + 1084, 3, 35, 17, 0, 1084, 1086, 1, 0, 0, 0, 1085, 1078, 1, 0, 0, 0, 1085, + 1079, 1, 0, 0, 0, 1085, 1082, 1, 0, 0, 0, 1086, 1091, 1, 0, 0, 0, 1087, + 1092, 3, 151, 75, 0, 1088, 1092, 3, 155, 77, 0, 1089, 1092, 3, 159, 79, + 0, 1090, 1092, 3, 163, 81, 0, 1091, 1087, 1, 0, 0, 0, 1091, 1088, 1, 0, + 0, 0, 1091, 1089, 1, 0, 0, 0, 1091, 1090, 1, 0, 0, 0, 1092, 168, 1, 0, + 0, 0, 1093, 1096, 3, 149, 74, 0, 1094, 1096, 3, 153, 76, 0, 1095, 1093, + 1, 0, 0, 0, 1095, 1094, 1, 0, 0, 0, 1096, 170, 1, 0, 0, 0, 1097, 1100, + 3, 157, 78, 0, 1098, 1100, 3, 161, 80, 0, 1099, 1097, 1, 0, 0, 0, 1099, + 1098, 1, 0, 0, 0, 1100, 172, 1, 0, 0, 0, 1101, 1104, 3, 35, 17, 0, 1102, + 1105, 3, 149, 74, 0, 1103, 1105, 3, 153, 76, 0, 1104, 1102, 1, 0, 0, 0, + 1104, 1103, 1, 0, 0, 0, 1105, 174, 1, 0, 0, 0, 1106, 1109, 3, 35, 17, 0, + 1107, 1110, 3, 157, 78, 0, 1108, 1110, 3, 161, 80, 0, 1109, 1107, 1, 0, + 0, 0, 1109, 1108, 1, 0, 0, 0, 1110, 176, 1, 0, 0, 0, 1111, 1114, 3, 3, + 1, 0, 1112, 1115, 3, 149, 74, 0, 1113, 1115, 3, 153, 76, 0, 1114, 1112, + 1, 0, 0, 0, 1114, 1113, 1, 0, 0, 0, 1115, 178, 1, 0, 0, 0, 1116, 1119, + 3, 3, 1, 0, 1117, 1120, 3, 157, 78, 0, 1118, 1120, 3, 161, 80, 0, 1119, + 1117, 1, 0, 0, 0, 1119, 1118, 1, 0, 0, 0, 1120, 180, 1, 0, 0, 0, 1121, + 1122, 3, 35, 17, 0, 1122, 1123, 3, 3, 1, 0, 1123, 1128, 1, 0, 0, 0, 1124, + 1125, 3, 3, 1, 0, 1125, 1126, 3, 35, 17, 0, 1126, 1128, 1, 0, 0, 0, 1127, + 1121, 1, 0, 0, 0, 1127, 1124, 1, 0, 0, 0, 1128, 1131, 1, 0, 0, 0, 1129, + 1132, 3, 149, 74, 0, 1130, 1132, 3, 153, 76, 0, 1131, 1129, 1, 0, 0, 0, + 1131, 1130, 1, 0, 0, 0, 1132, 182, 1, 0, 0, 0, 1133, 1134, 3, 35, 17, 0, + 1134, 1135, 3, 3, 1, 0, 1135, 1140, 1, 0, 0, 0, 1136, 1137, 3, 3, 1, 0, + 1137, 1138, 3, 35, 17, 0, 1138, 1140, 1, 0, 0, 0, 1139, 1133, 1, 0, 0, + 0, 1139, 1136, 1, 0, 0, 0, 1140, 1143, 1, 0, 0, 0, 1141, 1144, 3, 157, + 78, 0, 1142, 1144, 3, 161, 80, 0, 1143, 1141, 1, 0, 0, 0, 1143, 1142, 1, + 0, 0, 0, 1144, 184, 1, 0, 0, 0, 1145, 1148, 3, 71, 35, 0, 1146, 1148, 3, + 73, 36, 0, 1147, 1145, 1, 0, 0, 0, 1147, 1146, 1, 0, 0, 0, 1147, 1148, + 1, 0, 0, 0, 1148, 1149, 1, 0, 0, 0, 1149, 1150, 3, 193, 96, 0, 1150, 1152, + 3, 87, 43, 0, 1151, 1153, 3, 193, 96, 0, 1152, 1151, 1, 0, 0, 0, 1152, + 1153, 1, 0, 0, 0, 1153, 1160, 1, 0, 0, 0, 1154, 1157, 7, 4, 0, 0, 1155, + 1158, 3, 71, 35, 0, 1156, 1158, 3, 73, 36, 0, 1157, 1155, 1, 0, 0, 0, 1157, + 1156, 1, 0, 0, 0, 1157, 1158, 1, 0, 0, 0, 1158, 1159, 1, 0, 0, 0, 1159, + 1161, 3, 193, 96, 0, 1160, 1154, 1, 0, 0, 0, 1160, 1161, 1, 0, 0, 0, 1161, + 1188, 1, 0, 0, 0, 1162, 1165, 3, 71, 35, 0, 1163, 1165, 3, 73, 36, 0, 1164, + 1162, 1, 0, 0, 0, 1164, 1163, 1, 0, 0, 0, 1164, 1165, 1, 0, 0, 0, 1165, + 1167, 1, 0, 0, 0, 1166, 1168, 3, 193, 96, 0, 1167, 1166, 1, 0, 0, 0, 1167, + 1168, 1, 0, 0, 0, 1168, 1169, 1, 0, 0, 0, 1169, 1170, 3, 87, 43, 0, 1170, + 1177, 3, 193, 96, 0, 1171, 1174, 7, 4, 0, 0, 1172, 1175, 3, 71, 35, 0, + 1173, 1175, 3, 73, 36, 0, 1174, 1172, 1, 0, 0, 0, 1174, 1173, 1, 0, 0, + 0, 1174, 1175, 1, 0, 0, 0, 1175, 1176, 1, 0, 0, 0, 1176, 1178, 3, 193, + 96, 0, 1177, 1171, 1, 0, 0, 0, 1177, 1178, 1, 0, 0, 0, 1178, 1188, 1, 0, + 0, 0, 1179, 1180, 3, 193, 96, 0, 1180, 1183, 7, 4, 0, 0, 1181, 1184, 3, + 71, 35, 0, 1182, 1184, 3, 73, 36, 0, 1183, 1181, 1, 0, 0, 0, 1183, 1182, + 1, 0, 0, 0, 1183, 1184, 1, 0, 0, 0, 1184, 1185, 1, 0, 0, 0, 1185, 1186, + 3, 193, 96, 0, 1186, 1188, 1, 0, 0, 0, 1187, 1147, 1, 0, 0, 0, 1187, 1164, + 1, 0, 0, 0, 1187, 1179, 1, 0, 0, 0, 1188, 186, 1, 0, 0, 0, 1189, 1192, + 3, 193, 96, 0, 1190, 1192, 3, 195, 97, 0, 1191, 1189, 1, 0, 0, 0, 1191, + 1190, 1, 0, 0, 0, 1192, 188, 1, 0, 0, 0, 1193, 1194, 7, 30, 0, 0, 1194, + 190, 1, 0, 0, 0, 1195, 1196, 7, 31, 0, 0, 1196, 192, 1, 0, 0, 0, 1197, + 1199, 3, 189, 94, 0, 1198, 1197, 1, 0, 0, 0, 1199, 1200, 1, 0, 0, 0, 1200, + 1198, 1, 0, 0, 0, 1200, 1201, 1, 0, 0, 0, 1201, 194, 1, 0, 0, 0, 1202, + 1203, 5, 48, 0, 0, 1203, 1204, 7, 23, 0, 0, 1204, 1206, 1, 0, 0, 0, 1205, + 1207, 3, 191, 95, 0, 1206, 1205, 1, 0, 0, 0, 1207, 1208, 1, 0, 0, 0, 1208, + 1206, 1, 0, 0, 0, 1208, 1209, 1, 0, 0, 0, 1209, 196, 1, 0, 0, 0, 1210, + 1211, 7, 0, 0, 0, 1211, 1212, 7, 17, 0, 0, 1212, 1213, 7, 17, 0, 0, 1213, + 1214, 7, 0, 0, 0, 1214, 1215, 7, 24, 0, 0, 1215, 198, 1, 0, 0, 0, 1216, + 1217, 7, 0, 0, 0, 1217, 1218, 7, 11, 0, 0, 1218, 1219, 7, 11, 0, 0, 1219, + 200, 1, 0, 0, 0, 1220, 1221, 7, 0, 0, 0, 1221, 1222, 7, 18, 0, 0, 1222, + 202, 1, 0, 0, 0, 1223, 1224, 7, 0, 0, 0, 1224, 1225, 7, 18, 0, 0, 1225, + 1226, 7, 2, 0, 0, 1226, 204, 1, 0, 0, 0, 1227, 1228, 7, 1, 0, 0, 1228, + 1229, 7, 24, 0, 0, 1229, 206, 1, 0, 0, 0, 1230, 1231, 7, 2, 0, 0, 1231, + 1232, 7, 17, 0, 0, 1232, 1233, 7, 14, 0, 0, 1233, 1234, 7, 18, 0, 0, 1234, + 1235, 7, 18, 0, 0, 1235, 208, 1, 0, 0, 0, 1236, 1237, 7, 9, 0, 0, 1237, + 1238, 7, 14, 0, 0, 1238, 1239, 7, 8, 0, 0, 1239, 1240, 7, 13, 0, 0, 1240, + 210, 1, 0, 0, 0, 1241, 1242, 7, 3, 0, 0, 1242, 1243, 7, 4, 0, 0, 1243, + 1244, 7, 11, 0, 0, 1244, 1245, 7, 19, 0, 0, 1245, 1246, 7, 0, 0, 0, 1246, + 212, 1, 0, 0, 0, 1247, 1248, 7, 3, 0, 0, 1248, 1249, 7, 4, 0, 0, 1249, + 1250, 7, 18, 0, 0, 1250, 1251, 7, 2, 0, 0, 1251, 214, 1, 0, 0, 0, 1252, + 1253, 7, 3, 0, 0, 1253, 1254, 7, 8, 0, 0, 1254, 1255, 7, 5, 0, 0, 1255, + 1256, 7, 5, 0, 0, 1256, 1257, 7, 4, 0, 0, 1257, 1258, 7, 17, 0, 0, 1258, + 1259, 7, 4, 0, 0, 1259, 1260, 7, 13, 0, 0, 1260, 1261, 7, 19, 0, 0, 1261, + 1262, 7, 8, 0, 0, 1262, 1263, 7, 0, 0, 0, 1263, 1264, 7, 11, 0, 0, 1264, + 1265, 5, 95, 0, 0, 1265, 1266, 7, 15, 0, 0, 1266, 1267, 7, 17, 0, 0, 1267, + 1268, 7, 8, 0, 0, 1268, 1269, 7, 21, 0, 0, 1269, 1270, 7, 0, 0, 0, 1270, + 1271, 7, 2, 0, 0, 1271, 1272, 7, 24, 0, 0, 1272, 216, 1, 0, 0, 0, 1273, + 1274, 7, 3, 0, 0, 1274, 1275, 7, 8, 0, 0, 1275, 1276, 7, 18, 0, 0, 1276, + 1277, 7, 19, 0, 0, 1277, 1278, 7, 8, 0, 0, 1278, 1279, 7, 13, 0, 0, 1279, + 1280, 7, 2, 0, 0, 1280, 1281, 7, 19, 0, 0, 1281, 218, 1, 0, 0, 0, 1282, + 1283, 7, 4, 0, 0, 1283, 1284, 7, 15, 0, 0, 1284, 1285, 7, 18, 0, 0, 1285, + 1286, 7, 8, 0, 0, 1286, 1287, 7, 11, 0, 0, 1287, 1288, 7, 14, 0, 0, 1288, + 1289, 7, 13, 0, 0, 1289, 220, 1, 0, 0, 0, 1290, 1291, 7, 4, 0, 0, 1291, + 1292, 7, 23, 0, 0, 1292, 1293, 7, 2, 0, 0, 1293, 1294, 7, 4, 0, 0, 1294, + 1295, 7, 15, 0, 0, 1295, 1296, 7, 19, 0, 0, 1296, 222, 1, 0, 0, 0, 1297, + 1298, 7, 4, 0, 0, 1298, 1299, 7, 23, 0, 0, 1299, 1300, 7, 2, 0, 0, 1300, + 1301, 7, 11, 0, 0, 1301, 1302, 7, 20, 0, 0, 1302, 1303, 7, 3, 0, 0, 1303, + 1304, 7, 4, 0, 0, 1304, 224, 1, 0, 0, 0, 1305, 1306, 7, 5, 0, 0, 1306, + 1307, 7, 14, 0, 0, 1307, 1308, 7, 17, 0, 0, 1308, 226, 1, 0, 0, 0, 1309, + 1310, 7, 5, 0, 0, 1310, 1311, 7, 17, 0, 0, 1311, 1312, 7, 14, 0, 0, 1312, + 1313, 7, 12, 0, 0, 1313, 228, 1, 0, 0, 0, 1314, 1315, 7, 5, 0, 0, 1315, + 1316, 7, 20, 0, 0, 1316, 1317, 7, 11, 0, 0, 1317, 1318, 7, 11, 0, 0, 1318, + 230, 1, 0, 0, 0, 1319, 1320, 7, 8, 0, 0, 1320, 1321, 7, 13, 0, 0, 1321, + 232, 1, 0, 0, 0, 1322, 1323, 7, 8, 0, 0, 1323, 1324, 7, 13, 0, 0, 1324, + 1325, 7, 2, 0, 0, 1325, 1326, 7, 11, 0, 0, 1326, 1327, 7, 20, 0, 0, 1327, + 1328, 7, 3, 0, 0, 1328, 1329, 7, 4, 0, 0, 1329, 234, 1, 0, 0, 0, 1330, + 1331, 7, 8, 0, 0, 1331, 1332, 7, 13, 0, 0, 1332, 1333, 7, 13, 0, 0, 1333, + 1334, 7, 4, 0, 0, 1334, 1335, 7, 17, 0, 0, 1335, 236, 1, 0, 0, 0, 1336, + 1337, 7, 8, 0, 0, 1337, 1338, 7, 13, 0, 0, 1338, 1339, 7, 19, 0, 0, 1339, + 1340, 7, 4, 0, 0, 1340, 1341, 7, 17, 0, 0, 1341, 1342, 7, 18, 0, 0, 1342, + 1343, 7, 4, 0, 0, 1343, 1344, 7, 2, 0, 0, 1344, 1345, 7, 19, 0, 0, 1345, + 238, 1, 0, 0, 0, 1346, 1347, 7, 11, 0, 0, 1347, 1348, 7, 4, 0, 0, 1348, + 1349, 7, 5, 0, 0, 1349, 1350, 7, 19, 0, 0, 1350, 240, 1, 0, 0, 0, 1351, + 1352, 7, 11, 0, 0, 1352, 1353, 7, 8, 0, 0, 1353, 1354, 7, 12, 0, 0, 1354, + 1355, 7, 8, 0, 0, 1355, 1356, 7, 19, 0, 0, 1356, 242, 1, 0, 0, 0, 1357, + 1358, 7, 12, 0, 0, 1358, 1359, 7, 0, 0, 0, 1359, 1360, 7, 23, 0, 0, 1360, + 1361, 5, 95, 0, 0, 1361, 1362, 7, 6, 0, 0, 1362, 1363, 7, 17, 0, 0, 1363, + 1364, 7, 14, 0, 0, 1364, 1365, 7, 20, 0, 0, 1365, 1366, 7, 15, 0, 0, 1366, + 1367, 7, 18, 0, 0, 1367, 1368, 5, 95, 0, 0, 1368, 1369, 7, 2, 0, 0, 1369, + 1370, 7, 14, 0, 0, 1370, 1371, 7, 13, 0, 0, 1371, 1372, 7, 19, 0, 0, 1372, + 1373, 7, 17, 0, 0, 1373, 1374, 7, 8, 0, 0, 1374, 1375, 7, 1, 0, 0, 1375, + 1376, 7, 20, 0, 0, 1376, 1377, 7, 19, 0, 0, 1377, 1378, 7, 4, 0, 0, 1378, + 1379, 7, 3, 0, 0, 1379, 244, 1, 0, 0, 0, 1380, 1381, 7, 13, 0, 0, 1381, + 1382, 7, 20, 0, 0, 1382, 1383, 7, 11, 0, 0, 1383, 1384, 7, 11, 0, 0, 1384, + 246, 1, 0, 0, 0, 1385, 1386, 7, 13, 0, 0, 1386, 1387, 7, 20, 0, 0, 1387, + 1388, 7, 11, 0, 0, 1388, 1389, 7, 11, 0, 0, 1389, 1390, 7, 18, 0, 0, 1390, + 248, 1, 0, 0, 0, 1391, 1392, 7, 14, 0, 0, 1392, 1393, 7, 5, 0, 0, 1393, + 250, 1, 0, 0, 0, 1394, 1395, 7, 14, 0, 0, 1395, 1396, 7, 5, 0, 0, 1396, + 1397, 7, 5, 0, 0, 1397, 1398, 7, 18, 0, 0, 1398, 1399, 7, 4, 0, 0, 1399, + 1400, 7, 19, 0, 0, 1400, 252, 1, 0, 0, 0, 1401, 1402, 7, 14, 0, 0, 1402, + 1403, 7, 13, 0, 0, 1403, 254, 1, 0, 0, 0, 1404, 1405, 7, 14, 0, 0, 1405, + 1406, 7, 15, 0, 0, 1406, 1407, 7, 19, 0, 0, 1407, 1408, 7, 8, 0, 0, 1408, + 1409, 7, 14, 0, 0, 1409, 1410, 7, 13, 0, 0, 1410, 1411, 7, 18, 0, 0, 1411, + 256, 1, 0, 0, 0, 1412, 1413, 7, 14, 0, 0, 1413, 1414, 7, 17, 0, 0, 1414, + 1415, 7, 3, 0, 0, 1415, 1416, 7, 4, 0, 0, 1416, 1417, 7, 17, 0, 0, 1417, + 258, 1, 0, 0, 0, 1418, 1419, 7, 14, 0, 0, 1419, 1420, 7, 20, 0, 0, 1420, + 1421, 7, 19, 0, 0, 1421, 1422, 7, 4, 0, 0, 1422, 1423, 7, 17, 0, 0, 1423, + 260, 1, 0, 0, 0, 1424, 1425, 7, 15, 0, 0, 1425, 1426, 7, 4, 0, 0, 1426, + 1427, 7, 17, 0, 0, 1427, 1428, 7, 2, 0, 0, 1428, 1429, 7, 4, 0, 0, 1429, + 1430, 7, 13, 0, 0, 1430, 1431, 7, 19, 0, 0, 1431, 262, 1, 0, 0, 0, 1432, + 1433, 7, 15, 0, 0, 1433, 1434, 7, 8, 0, 0, 1434, 1435, 7, 21, 0, 0, 1435, + 1436, 7, 14, 0, 0, 1436, 1437, 7, 19, 0, 0, 1437, 264, 1, 0, 0, 0, 1438, + 1439, 7, 15, 0, 0, 1439, 1440, 7, 17, 0, 0, 1440, 1441, 7, 8, 0, 0, 1441, + 1442, 7, 21, 0, 0, 1442, 1443, 7, 0, 0, 0, 1443, 1444, 7, 2, 0, 0, 1444, + 1445, 7, 24, 0, 0, 1445, 1446, 5, 95, 0, 0, 1446, 1447, 7, 20, 0, 0, 1447, + 1448, 7, 13, 0, 0, 1448, 1449, 7, 8, 0, 0, 1449, 1450, 7, 19, 0, 0, 1450, + 1451, 5, 95, 0, 0, 1451, 1452, 7, 2, 0, 0, 1452, 1453, 7, 14, 0, 0, 1453, + 1454, 7, 11, 0, 0, 1454, 1455, 7, 20, 0, 0, 1455, 1456, 7, 12, 0, 0, 1456, + 1457, 7, 13, 0, 0, 1457, 266, 1, 0, 0, 0, 1458, 1459, 7, 17, 0, 0, 1459, + 1460, 7, 8, 0, 0, 1460, 1461, 7, 6, 0, 0, 1461, 1462, 7, 7, 0, 0, 1462, + 1463, 7, 19, 0, 0, 1463, 268, 1, 0, 0, 0, 1464, 1465, 7, 17, 0, 0, 1465, + 1466, 7, 4, 0, 0, 1466, 1467, 7, 2, 0, 0, 1467, 1468, 7, 20, 0, 0, 1468, + 1469, 7, 17, 0, 0, 1469, 1470, 7, 18, 0, 0, 1470, 1471, 7, 8, 0, 0, 1471, + 1472, 7, 21, 0, 0, 1472, 1473, 7, 4, 0, 0, 1473, 270, 1, 0, 0, 0, 1474, + 1475, 7, 17, 0, 0, 1475, 1476, 7, 4, 0, 0, 1476, 1477, 7, 15, 0, 0, 1477, + 1478, 7, 11, 0, 0, 1478, 1479, 7, 0, 0, 0, 1479, 1480, 7, 2, 0, 0, 1480, + 1481, 7, 4, 0, 0, 1481, 272, 1, 0, 0, 0, 1482, 1483, 7, 20, 0, 0, 1483, + 1484, 7, 13, 0, 0, 1484, 1485, 7, 15, 0, 0, 1485, 1486, 7, 8, 0, 0, 1486, + 1487, 7, 21, 0, 0, 1487, 1488, 7, 14, 0, 0, 1488, 1489, 7, 19, 0, 0, 1489, + 274, 1, 0, 0, 0, 1490, 1491, 7, 18, 0, 0, 1491, 1492, 7, 4, 0, 0, 1492, + 1493, 7, 11, 0, 0, 1493, 1494, 7, 4, 0, 0, 1494, 1495, 7, 2, 0, 0, 1495, + 1496, 7, 19, 0, 0, 1496, 276, 1, 0, 0, 0, 1497, 1498, 7, 18, 0, 0, 1498, + 1499, 7, 19, 0, 0, 1499, 1500, 7, 17, 0, 0, 1500, 1501, 7, 20, 0, 0, 1501, + 1502, 7, 2, 0, 0, 1502, 1503, 7, 19, 0, 0, 1503, 278, 1, 0, 0, 0, 1504, + 1505, 7, 18, 0, 0, 1505, 1506, 7, 24, 0, 0, 1506, 1507, 7, 18, 0, 0, 1507, + 1508, 7, 19, 0, 0, 1508, 1509, 7, 4, 0, 0, 1509, 1510, 7, 12, 0, 0, 1510, + 280, 1, 0, 0, 0, 1511, 1512, 7, 18, 0, 0, 1512, 1513, 7, 24, 0, 0, 1513, + 1514, 7, 18, 0, 0, 1514, 1515, 7, 19, 0, 0, 1515, 1516, 7, 4, 0, 0, 1516, + 1517, 7, 12, 0, 0, 1517, 1518, 5, 95, 0, 0, 1518, 1519, 7, 19, 0, 0, 1519, + 1520, 7, 8, 0, 0, 1520, 1521, 7, 12, 0, 0, 1521, 1522, 7, 4, 0, 0, 1522, + 282, 1, 0, 0, 0, 1523, 1524, 7, 19, 0, 0, 1524, 1525, 7, 0, 0, 0, 1525, + 1526, 7, 1, 0, 0, 1526, 1527, 7, 11, 0, 0, 1527, 1528, 7, 4, 0, 0, 1528, + 1529, 7, 18, 0, 0, 1529, 1530, 7, 0, 0, 0, 1530, 1531, 7, 12, 0, 0, 1531, + 1532, 7, 15, 0, 0, 1532, 1533, 7, 11, 0, 0, 1533, 1534, 7, 4, 0, 0, 1534, + 284, 1, 0, 0, 0, 1535, 1536, 7, 20, 0, 0, 1536, 1537, 7, 13, 0, 0, 1537, + 1538, 7, 8, 0, 0, 1538, 1539, 7, 14, 0, 0, 1539, 1540, 7, 13, 0, 0, 1540, + 286, 1, 0, 0, 0, 1541, 1542, 7, 20, 0, 0, 1542, 1543, 7, 13, 0, 0, 1543, + 1544, 7, 13, 0, 0, 1544, 1545, 7, 4, 0, 0, 1545, 1546, 7, 18, 0, 0, 1546, + 1547, 7, 19, 0, 0, 1547, 288, 1, 0, 0, 0, 1548, 1549, 7, 20, 0, 0, 1549, + 1550, 7, 18, 0, 0, 1550, 1551, 7, 8, 0, 0, 1551, 1552, 7, 13, 0, 0, 1552, + 1553, 7, 6, 0, 0, 1553, 290, 1, 0, 0, 0, 1554, 1555, 7, 21, 0, 0, 1555, + 1556, 7, 0, 0, 0, 1556, 1557, 7, 11, 0, 0, 1557, 1558, 7, 20, 0, 0, 1558, + 1559, 7, 4, 0, 0, 1559, 292, 1, 0, 0, 0, 1560, 1561, 7, 22, 0, 0, 1561, + 1562, 7, 8, 0, 0, 1562, 1563, 7, 19, 0, 0, 1563, 1564, 7, 7, 0, 0, 1564, + 294, 1, 0, 0, 0, 1565, 1566, 7, 19, 0, 0, 1566, 1567, 7, 17, 0, 0, 1567, + 1568, 7, 20, 0, 0, 1568, 1569, 7, 4, 0, 0, 1569, 296, 1, 0, 0, 0, 1570, + 1571, 7, 5, 0, 0, 1571, 1572, 7, 0, 0, 0, 1572, 1573, 7, 11, 0, 0, 1573, + 1574, 7, 18, 0, 0, 1574, 1575, 7, 4, 0, 0, 1575, 298, 1, 0, 0, 0, 1576, + 1577, 7, 13, 0, 0, 1577, 1578, 7, 20, 0, 0, 1578, 1579, 7, 12, 0, 0, 1579, + 1580, 7, 4, 0, 0, 1580, 1581, 7, 17, 0, 0, 1581, 1582, 7, 8, 0, 0, 1582, + 1583, 7, 2, 0, 0, 1583, 300, 1, 0, 0, 0, 1584, 1585, 7, 3, 0, 0, 1585, + 1586, 7, 4, 0, 0, 1586, 1587, 7, 2, 0, 0, 1587, 1588, 7, 8, 0, 0, 1588, + 1589, 7, 12, 0, 0, 1589, 1590, 7, 0, 0, 0, 1590, 1591, 7, 11, 0, 0, 1591, + 302, 1, 0, 0, 0, 1592, 1593, 7, 1, 0, 0, 1593, 1594, 7, 8, 0, 0, 1594, + 1595, 7, 6, 0, 0, 1595, 1596, 7, 13, 0, 0, 1596, 1597, 7, 20, 0, 0, 1597, + 1598, 7, 12, 0, 0, 1598, 1599, 7, 4, 0, 0, 1599, 1600, 7, 17, 0, 0, 1600, + 1601, 7, 8, 0, 0, 1601, 1602, 7, 2, 0, 0, 1602, 304, 1, 0, 0, 0, 1603, + 1604, 7, 1, 0, 0, 1604, 1605, 7, 8, 0, 0, 1605, 1606, 7, 6, 0, 0, 1606, + 1607, 7, 3, 0, 0, 1607, 1608, 7, 4, 0, 0, 1608, 1609, 7, 2, 0, 0, 1609, + 1610, 7, 8, 0, 0, 1610, 1611, 7, 12, 0, 0, 1611, 1612, 7, 0, 0, 0, 1612, + 1613, 7, 11, 0, 0, 1613, 306, 1, 0, 0, 0, 1614, 1615, 7, 13, 0, 0, 1615, + 1616, 7, 14, 0, 0, 1616, 1617, 7, 19, 0, 0, 1617, 308, 1, 0, 0, 0, 1618, + 1619, 7, 0, 0, 0, 1619, 1620, 7, 13, 0, 0, 1620, 1621, 7, 3, 0, 0, 1621, + 310, 1, 0, 0, 0, 1622, 1623, 7, 14, 0, 0, 1623, 1624, 7, 17, 0, 0, 1624, + 312, 1, 0, 0, 0, 1625, 1626, 7, 9, 0, 0, 1626, 1627, 7, 18, 0, 0, 1627, + 1628, 7, 14, 0, 0, 1628, 1629, 7, 13, 0, 0, 1629, 314, 1, 0, 0, 0, 1630, + 1631, 7, 3, 0, 0, 1631, 1632, 7, 0, 0, 0, 1632, 1633, 7, 19, 0, 0, 1633, + 1634, 7, 4, 0, 0, 1634, 316, 1, 0, 0, 0, 1635, 1636, 7, 19, 0, 0, 1636, + 1637, 7, 8, 0, 0, 1637, 1638, 7, 12, 0, 0, 1638, 1639, 7, 4, 0, 0, 1639, + 318, 1, 0, 0, 0, 1640, 1641, 7, 3, 0, 0, 1641, 1642, 7, 0, 0, 0, 1642, + 1643, 7, 19, 0, 0, 1643, 1644, 7, 4, 0, 0, 1644, 1645, 7, 19, 0, 0, 1645, + 1646, 7, 8, 0, 0, 1646, 1647, 7, 12, 0, 0, 1647, 1648, 7, 4, 0, 0, 1648, + 320, 1, 0, 0, 0, 1649, 1650, 7, 19, 0, 0, 1650, 1651, 7, 8, 0, 0, 1651, + 1652, 7, 12, 0, 0, 1652, 1653, 7, 4, 0, 0, 1653, 1654, 7, 18, 0, 0, 1654, + 1655, 7, 19, 0, 0, 1655, 1656, 7, 0, 0, 0, 1656, 1657, 7, 12, 0, 0, 1657, + 1658, 7, 15, 0, 0, 1658, 322, 1, 0, 0, 0, 1659, 1660, 7, 17, 0, 0, 1660, + 1661, 7, 0, 0, 0, 1661, 1662, 7, 13, 0, 0, 1662, 1663, 7, 6, 0, 0, 1663, + 1664, 7, 4, 0, 0, 1664, 324, 1, 0, 0, 0, 1665, 1666, 7, 8, 0, 0, 1666, + 1667, 7, 13, 0, 0, 1667, 1668, 7, 19, 0, 0, 1668, 1669, 7, 4, 0, 0, 1669, + 1670, 7, 17, 0, 0, 1670, 1671, 7, 21, 0, 0, 1671, 1672, 7, 0, 0, 0, 1672, + 1673, 7, 11, 0, 0, 1673, 326, 1, 0, 0, 0, 1674, 1675, 7, 18, 0, 0, 1675, + 1676, 7, 8, 0, 0, 1676, 1677, 7, 12, 0, 0, 1677, 1678, 7, 15, 0, 0, 1678, + 1679, 7, 11, 0, 0, 1679, 1680, 7, 4, 0, 0, 1680, 328, 1, 0, 0, 0, 1681, + 1682, 7, 0, 0, 0, 1682, 1683, 7, 1, 0, 0, 1683, 1684, 7, 14, 0, 0, 1684, + 1685, 7, 17, 0, 0, 1685, 1686, 7, 19, 0, 0, 1686, 330, 1, 0, 0, 0, 1687, + 1688, 7, 0, 0, 0, 1688, 1689, 7, 2, 0, 0, 1689, 1690, 7, 2, 0, 0, 1690, + 1691, 7, 4, 0, 0, 1691, 1692, 7, 18, 0, 0, 1692, 1693, 7, 18, 0, 0, 1693, + 332, 1, 0, 0, 0, 1694, 1695, 7, 0, 0, 0, 1695, 1696, 7, 2, 0, 0, 1696, + 1697, 7, 19, 0, 0, 1697, 1698, 7, 8, 0, 0, 1698, 1699, 7, 14, 0, 0, 1699, + 1700, 7, 13, 0, 0, 1700, 334, 1, 0, 0, 0, 1701, 1702, 7, 0, 0, 0, 1702, + 1703, 7, 6, 0, 0, 1703, 1704, 7, 6, 0, 0, 1704, 1705, 7, 17, 0, 0, 1705, + 1706, 7, 4, 0, 0, 1706, 1707, 7, 6, 0, 0, 1707, 1708, 7, 0, 0, 0, 1708, + 1709, 7, 19, 0, 0, 1709, 1710, 7, 4, 0, 0, 1710, 336, 1, 0, 0, 0, 1711, + 1712, 7, 0, 0, 0, 1712, 1713, 7, 3, 0, 0, 1713, 1714, 7, 3, 0, 0, 1714, + 338, 1, 0, 0, 0, 1715, 1716, 7, 0, 0, 0, 1716, 1717, 7, 11, 0, 0, 1717, + 1718, 7, 19, 0, 0, 1718, 1719, 7, 4, 0, 0, 1719, 1720, 7, 17, 0, 0, 1720, + 340, 1, 0, 0, 0, 1721, 1722, 7, 0, 0, 0, 1722, 1723, 7, 11, 0, 0, 1723, + 1724, 7, 22, 0, 0, 1724, 1725, 7, 0, 0, 0, 1725, 1726, 7, 24, 0, 0, 1726, + 1727, 7, 18, 0, 0, 1727, 342, 1, 0, 0, 0, 1728, 1729, 7, 0, 0, 0, 1729, + 1730, 7, 13, 0, 0, 1730, 1731, 7, 0, 0, 0, 1731, 1732, 7, 11, 0, 0, 1732, + 1733, 7, 24, 0, 0, 1733, 1734, 7, 25, 0, 0, 1734, 1735, 7, 4, 0, 0, 1735, + 344, 1, 0, 0, 0, 1736, 1737, 7, 0, 0, 0, 1737, 1738, 7, 15, 0, 0, 1738, + 1739, 7, 15, 0, 0, 1739, 1740, 7, 17, 0, 0, 1740, 1741, 7, 14, 0, 0, 1741, + 1742, 7, 23, 0, 0, 1742, 346, 1, 0, 0, 0, 1743, 1744, 7, 0, 0, 0, 1744, + 1745, 7, 17, 0, 0, 1745, 1746, 7, 4, 0, 0, 1746, 348, 1, 0, 0, 0, 1747, + 1748, 7, 0, 0, 0, 1748, 1749, 7, 18, 0, 0, 1749, 1750, 7, 18, 0, 0, 1750, + 1751, 7, 4, 0, 0, 1751, 1752, 7, 17, 0, 0, 1752, 1753, 7, 19, 0, 0, 1753, + 350, 1, 0, 0, 0, 1754, 1755, 7, 1, 0, 0, 1755, 1756, 7, 0, 0, 0, 1756, + 1757, 7, 19, 0, 0, 1757, 1758, 7, 2, 0, 0, 1758, 1759, 7, 7, 0, 0, 1759, + 352, 1, 0, 0, 0, 1760, 1761, 7, 1, 0, 0, 1761, 1762, 7, 4, 0, 0, 1762, + 1763, 7, 6, 0, 0, 1763, 1764, 7, 8, 0, 0, 1764, 1765, 7, 13, 0, 0, 1765, + 354, 1, 0, 0, 0, 1766, 1767, 7, 1, 0, 0, 1767, 1768, 7, 17, 0, 0, 1768, + 1769, 7, 4, 0, 0, 1769, 1770, 7, 0, 0, 0, 1770, 1771, 7, 10, 0, 0, 1771, + 356, 1, 0, 0, 0, 1772, 1773, 7, 2, 0, 0, 1773, 1774, 7, 0, 0, 0, 1774, + 1775, 7, 11, 0, 0, 1775, 1776, 7, 11, 0, 0, 1776, 358, 1, 0, 0, 0, 1777, + 1778, 7, 2, 0, 0, 1778, 1779, 7, 0, 0, 0, 1779, 1780, 7, 18, 0, 0, 1780, + 1781, 7, 2, 0, 0, 1781, 1782, 7, 0, 0, 0, 1782, 1783, 7, 3, 0, 0, 1783, + 1784, 7, 4, 0, 0, 1784, 360, 1, 0, 0, 0, 1785, 1786, 7, 2, 0, 0, 1786, + 1787, 7, 7, 0, 0, 1787, 1788, 7, 4, 0, 0, 1788, 1789, 7, 2, 0, 0, 1789, + 1790, 7, 10, 0, 0, 1790, 362, 1, 0, 0, 0, 1791, 1792, 7, 2, 0, 0, 1792, + 1793, 7, 11, 0, 0, 1793, 1794, 7, 0, 0, 0, 1794, 1795, 7, 12, 0, 0, 1795, + 1796, 7, 15, 0, 0, 1796, 1797, 7, 4, 0, 0, 1797, 1798, 7, 3, 0, 0, 1798, + 364, 1, 0, 0, 0, 1799, 1800, 7, 2, 0, 0, 1800, 1801, 7, 11, 0, 0, 1801, + 1802, 7, 14, 0, 0, 1802, 1803, 7, 13, 0, 0, 1803, 1804, 7, 4, 0, 0, 1804, + 366, 1, 0, 0, 0, 1805, 1806, 7, 2, 0, 0, 1806, 1807, 7, 14, 0, 0, 1807, + 1808, 7, 15, 0, 0, 1808, 1809, 7, 24, 0, 0, 1809, 368, 1, 0, 0, 0, 1810, + 1811, 7, 2, 0, 0, 1811, 1812, 7, 11, 0, 0, 1812, 1813, 7, 20, 0, 0, 1813, + 1814, 7, 18, 0, 0, 1814, 1815, 7, 19, 0, 0, 1815, 1816, 7, 4, 0, 0, 1816, + 1817, 7, 17, 0, 0, 1817, 370, 1, 0, 0, 0, 1818, 1819, 7, 2, 0, 0, 1819, + 1820, 7, 14, 0, 0, 1820, 1821, 7, 11, 0, 0, 1821, 1822, 7, 20, 0, 0, 1822, + 1823, 7, 12, 0, 0, 1823, 1824, 7, 13, 0, 0, 1824, 372, 1, 0, 0, 0, 1825, + 1826, 7, 2, 0, 0, 1826, 1827, 7, 14, 0, 0, 1827, 1828, 7, 11, 0, 0, 1828, + 1829, 7, 20, 0, 0, 1829, 1830, 7, 12, 0, 0, 1830, 1831, 7, 13, 0, 0, 1831, + 1832, 7, 18, 0, 0, 1832, 374, 1, 0, 0, 0, 1833, 1834, 7, 2, 0, 0, 1834, + 1835, 7, 14, 0, 0, 1835, 1836, 7, 12, 0, 0, 1836, 1837, 7, 12, 0, 0, 1837, + 1838, 7, 8, 0, 0, 1838, 1839, 7, 19, 0, 0, 1839, 376, 1, 0, 0, 0, 1840, + 1841, 7, 2, 0, 0, 1841, 1842, 7, 14, 0, 0, 1842, 1843, 7, 13, 0, 0, 1843, + 1844, 7, 13, 0, 0, 1844, 1845, 7, 4, 0, 0, 1845, 1846, 7, 2, 0, 0, 1846, + 1847, 7, 19, 0, 0, 1847, 1848, 7, 8, 0, 0, 1848, 1849, 7, 14, 0, 0, 1849, + 1850, 7, 13, 0, 0, 1850, 378, 1, 0, 0, 0, 1851, 1852, 7, 2, 0, 0, 1852, + 1853, 7, 14, 0, 0, 1853, 1854, 7, 13, 0, 0, 1854, 1855, 7, 18, 0, 0, 1855, + 1856, 7, 19, 0, 0, 1856, 1857, 7, 0, 0, 0, 1857, 1858, 7, 13, 0, 0, 1858, + 1859, 7, 19, 0, 0, 1859, 380, 1, 0, 0, 0, 1860, 1861, 7, 2, 0, 0, 1861, + 1862, 7, 14, 0, 0, 1862, 1863, 7, 13, 0, 0, 1863, 1864, 7, 18, 0, 0, 1864, + 1865, 7, 19, 0, 0, 1865, 1866, 7, 17, 0, 0, 1866, 1867, 7, 0, 0, 0, 1867, + 1868, 7, 8, 0, 0, 1868, 1869, 7, 13, 0, 0, 1869, 1870, 7, 19, 0, 0, 1870, + 382, 1, 0, 0, 0, 1871, 1872, 7, 2, 0, 0, 1872, 1873, 7, 14, 0, 0, 1873, + 1874, 7, 13, 0, 0, 1874, 1875, 7, 19, 0, 0, 1875, 1876, 7, 8, 0, 0, 1876, + 1877, 7, 13, 0, 0, 1877, 1878, 7, 20, 0, 0, 1878, 1879, 7, 4, 0, 0, 1879, + 384, 1, 0, 0, 0, 1880, 1881, 7, 2, 0, 0, 1881, 1882, 7, 14, 0, 0, 1882, + 1883, 7, 17, 0, 0, 1883, 1884, 7, 17, 0, 0, 1884, 1885, 7, 4, 0, 0, 1885, + 1886, 7, 18, 0, 0, 1886, 1887, 7, 15, 0, 0, 1887, 1888, 7, 14, 0, 0, 1888, + 1889, 7, 13, 0, 0, 1889, 1890, 7, 3, 0, 0, 1890, 1891, 7, 8, 0, 0, 1891, + 1892, 7, 13, 0, 0, 1892, 1893, 7, 6, 0, 0, 1893, 386, 1, 0, 0, 0, 1894, + 1895, 7, 2, 0, 0, 1895, 1896, 7, 24, 0, 0, 1896, 1897, 7, 2, 0, 0, 1897, + 1898, 7, 11, 0, 0, 1898, 1899, 7, 4, 0, 0, 1899, 388, 1, 0, 0, 0, 1900, + 1901, 7, 3, 0, 0, 1901, 1902, 7, 0, 0, 0, 1902, 1903, 7, 19, 0, 0, 1903, + 1904, 7, 0, 0, 0, 1904, 390, 1, 0, 0, 0, 1905, 1906, 7, 3, 0, 0, 1906, + 1907, 7, 0, 0, 0, 1907, 1908, 7, 19, 0, 0, 1908, 1909, 7, 0, 0, 0, 1909, + 1910, 7, 1, 0, 0, 1910, 1911, 7, 0, 0, 0, 1911, 1912, 7, 18, 0, 0, 1912, + 1913, 7, 4, 0, 0, 1913, 392, 1, 0, 0, 0, 1914, 1915, 7, 3, 0, 0, 1915, + 1916, 7, 4, 0, 0, 1916, 1917, 7, 2, 0, 0, 1917, 1918, 7, 11, 0, 0, 1918, + 1919, 7, 0, 0, 0, 1919, 1920, 7, 17, 0, 0, 1920, 1921, 7, 4, 0, 0, 1921, + 394, 1, 0, 0, 0, 1922, 1923, 7, 3, 0, 0, 1923, 1924, 7, 4, 0, 0, 1924, + 1925, 7, 5, 0, 0, 1925, 1926, 7, 8, 0, 0, 1926, 1927, 7, 13, 0, 0, 1927, + 1928, 7, 4, 0, 0, 1928, 1929, 7, 17, 0, 0, 1929, 396, 1, 0, 0, 0, 1930, + 1931, 7, 3, 0, 0, 1931, 1932, 7, 4, 0, 0, 1932, 1933, 7, 11, 0, 0, 1933, + 1934, 7, 4, 0, 0, 1934, 1935, 7, 19, 0, 0, 1935, 1936, 7, 4, 0, 0, 1936, + 398, 1, 0, 0, 0, 1937, 1938, 7, 3, 0, 0, 1938, 1939, 7, 4, 0, 0, 1939, + 1940, 7, 11, 0, 0, 1940, 1941, 7, 4, 0, 0, 1941, 1942, 7, 19, 0, 0, 1942, + 1943, 7, 8, 0, 0, 1943, 1944, 7, 14, 0, 0, 1944, 1945, 7, 13, 0, 0, 1945, + 400, 1, 0, 0, 0, 1946, 1947, 7, 3, 0, 0, 1947, 1948, 7, 4, 0, 0, 1948, + 1949, 7, 15, 0, 0, 1949, 1950, 7, 19, 0, 0, 1950, 1951, 7, 7, 0, 0, 1951, + 402, 1, 0, 0, 0, 1952, 1953, 7, 3, 0, 0, 1953, 1954, 7, 4, 0, 0, 1954, + 1955, 7, 18, 0, 0, 1955, 1956, 7, 2, 0, 0, 1956, 1957, 7, 17, 0, 0, 1957, + 1958, 7, 8, 0, 0, 1958, 1959, 7, 1, 0, 0, 1959, 1960, 7, 4, 0, 0, 1960, + 404, 1, 0, 0, 0, 1961, 1962, 7, 3, 0, 0, 1962, 1963, 7, 4, 0, 0, 1963, + 1964, 7, 19, 0, 0, 1964, 1965, 7, 4, 0, 0, 1965, 1966, 7, 17, 0, 0, 1966, + 1967, 7, 12, 0, 0, 1967, 1968, 7, 8, 0, 0, 1968, 1969, 7, 13, 0, 0, 1969, + 1970, 7, 8, 0, 0, 1970, 1971, 7, 18, 0, 0, 1971, 1972, 7, 19, 0, 0, 1972, + 1973, 7, 8, 0, 0, 1973, 1974, 7, 2, 0, 0, 1974, 406, 1, 0, 0, 0, 1975, + 1976, 7, 3, 0, 0, 1976, 1977, 7, 14, 0, 0, 1977, 408, 1, 0, 0, 0, 1978, + 1979, 7, 3, 0, 0, 1979, 1980, 7, 17, 0, 0, 1980, 1981, 7, 14, 0, 0, 1981, + 1982, 7, 15, 0, 0, 1982, 410, 1, 0, 0, 0, 1983, 1984, 7, 4, 0, 0, 1984, + 1985, 7, 11, 0, 0, 1985, 1986, 7, 18, 0, 0, 1986, 1987, 7, 4, 0, 0, 1987, + 1988, 7, 8, 0, 0, 1988, 1989, 7, 5, 0, 0, 1989, 412, 1, 0, 0, 0, 1990, + 1991, 7, 4, 0, 0, 1991, 1992, 7, 13, 0, 0, 1992, 1993, 7, 5, 0, 0, 1993, + 1994, 7, 14, 0, 0, 1994, 1995, 7, 17, 0, 0, 1995, 1996, 7, 2, 0, 0, 1996, + 1997, 7, 4, 0, 0, 1997, 1998, 7, 3, 0, 0, 1998, 414, 1, 0, 0, 0, 1999, + 2000, 7, 4, 0, 0, 2000, 2001, 7, 17, 0, 0, 2001, 2002, 7, 17, 0, 0, 2002, + 2003, 7, 14, 0, 0, 2003, 2004, 7, 17, 0, 0, 2004, 416, 1, 0, 0, 0, 2005, + 2006, 7, 4, 0, 0, 2006, 2007, 7, 23, 0, 0, 2007, 2008, 7, 2, 0, 0, 2008, + 2009, 7, 4, 0, 0, 2009, 2010, 7, 15, 0, 0, 2010, 2011, 7, 19, 0, 0, 2011, + 2012, 7, 8, 0, 0, 2012, 2013, 7, 14, 0, 0, 2013, 2014, 7, 13, 0, 0, 2014, + 418, 1, 0, 0, 0, 2015, 2016, 7, 4, 0, 0, 2016, 2017, 7, 23, 0, 0, 2017, + 2018, 7, 4, 0, 0, 2018, 2019, 7, 2, 0, 0, 2019, 2020, 7, 20, 0, 0, 2020, + 2021, 7, 19, 0, 0, 2021, 2022, 7, 4, 0, 0, 2022, 420, 1, 0, 0, 0, 2023, + 2024, 7, 4, 0, 0, 2024, 2025, 7, 23, 0, 0, 2025, 2026, 7, 15, 0, 0, 2026, + 2027, 7, 11, 0, 0, 2027, 2028, 7, 0, 0, 0, 2028, 2029, 7, 8, 0, 0, 2029, + 2030, 7, 13, 0, 0, 2030, 422, 1, 0, 0, 0, 2031, 2032, 7, 4, 0, 0, 2032, + 2033, 7, 23, 0, 0, 2033, 2034, 7, 15, 0, 0, 2034, 2035, 7, 14, 0, 0, 2035, + 2036, 7, 17, 0, 0, 2036, 2037, 7, 19, 0, 0, 2037, 424, 1, 0, 0, 0, 2038, + 2039, 7, 4, 0, 0, 2039, 2040, 7, 23, 0, 0, 2040, 2041, 7, 19, 0, 0, 2041, + 2042, 7, 4, 0, 0, 2042, 2043, 7, 13, 0, 0, 2043, 2044, 7, 3, 0, 0, 2044, + 426, 1, 0, 0, 0, 2045, 2046, 7, 4, 0, 0, 2046, 2047, 7, 23, 0, 0, 2047, + 2048, 7, 19, 0, 0, 2048, 2049, 7, 4, 0, 0, 2049, 2050, 7, 17, 0, 0, 2050, + 2051, 7, 13, 0, 0, 2051, 2052, 7, 0, 0, 0, 2052, 2053, 7, 11, 0, 0, 2053, + 428, 1, 0, 0, 0, 2054, 2055, 7, 5, 0, 0, 2055, 2056, 7, 8, 0, 0, 2056, + 2057, 7, 11, 0, 0, 2057, 2058, 7, 4, 0, 0, 2058, 2059, 7, 18, 0, 0, 2059, + 430, 1, 0, 0, 0, 2060, 2061, 7, 5, 0, 0, 2061, 2062, 7, 8, 0, 0, 2062, + 2063, 7, 11, 0, 0, 2063, 2064, 7, 19, 0, 0, 2064, 2065, 7, 4, 0, 0, 2065, + 2066, 7, 17, 0, 0, 2066, 432, 1, 0, 0, 0, 2067, 2068, 7, 5, 0, 0, 2068, + 2069, 7, 8, 0, 0, 2069, 2070, 7, 11, 0, 0, 2070, 2071, 7, 11, 0, 0, 2071, + 434, 1, 0, 0, 0, 2072, 2073, 7, 5, 0, 0, 2073, 2074, 7, 8, 0, 0, 2074, + 2075, 7, 17, 0, 0, 2075, 2076, 7, 18, 0, 0, 2076, 2077, 7, 19, 0, 0, 2077, + 436, 1, 0, 0, 0, 2078, 2079, 7, 5, 0, 0, 2079, 2080, 7, 14, 0, 0, 2080, + 2081, 7, 17, 0, 0, 2081, 2082, 7, 4, 0, 0, 2082, 2083, 7, 8, 0, 0, 2083, + 2084, 7, 6, 0, 0, 2084, 2085, 7, 13, 0, 0, 2085, 438, 1, 0, 0, 0, 2086, + 2087, 7, 5, 0, 0, 2087, 2088, 7, 14, 0, 0, 2088, 2089, 7, 17, 0, 0, 2089, + 2090, 7, 12, 0, 0, 2090, 2091, 7, 0, 0, 0, 2091, 2092, 7, 19, 0, 0, 2092, + 440, 1, 0, 0, 0, 2093, 2094, 7, 5, 0, 0, 2094, 2095, 7, 20, 0, 0, 2095, + 2096, 7, 13, 0, 0, 2096, 2097, 7, 2, 0, 0, 2097, 2098, 7, 19, 0, 0, 2098, + 2099, 7, 8, 0, 0, 2099, 2100, 7, 14, 0, 0, 2100, 2101, 7, 13, 0, 0, 2101, + 442, 1, 0, 0, 0, 2102, 2103, 7, 6, 0, 0, 2103, 2104, 7, 4, 0, 0, 2104, + 2105, 7, 13, 0, 0, 2105, 2106, 7, 4, 0, 0, 2106, 2107, 7, 17, 0, 0, 2107, + 2108, 7, 0, 0, 0, 2108, 2109, 7, 19, 0, 0, 2109, 2110, 7, 4, 0, 0, 2110, + 2111, 7, 3, 0, 0, 2111, 444, 1, 0, 0, 0, 2112, 2113, 7, 6, 0, 0, 2113, + 2114, 7, 17, 0, 0, 2114, 2115, 7, 0, 0, 0, 2115, 2116, 7, 13, 0, 0, 2116, + 2117, 7, 19, 0, 0, 2117, 446, 1, 0, 0, 0, 2118, 2119, 7, 6, 0, 0, 2119, + 2120, 7, 17, 0, 0, 2120, 2121, 7, 14, 0, 0, 2121, 2122, 7, 20, 0, 0, 2122, + 2123, 7, 15, 0, 0, 2123, 2124, 5, 95, 0, 0, 2124, 2125, 7, 17, 0, 0, 2125, + 2126, 7, 14, 0, 0, 2126, 2127, 7, 22, 0, 0, 2127, 2128, 7, 18, 0, 0, 2128, + 448, 1, 0, 0, 0, 2129, 2130, 7, 7, 0, 0, 2130, 2131, 7, 8, 0, 0, 2131, + 2132, 7, 3, 0, 0, 2132, 2133, 7, 3, 0, 0, 2133, 2134, 7, 4, 0, 0, 2134, + 2135, 7, 13, 0, 0, 2135, 450, 1, 0, 0, 0, 2136, 2137, 7, 8, 0, 0, 2137, + 2138, 7, 3, 0, 0, 2138, 2139, 7, 4, 0, 0, 2139, 2140, 7, 13, 0, 0, 2140, + 2141, 7, 19, 0, 0, 2141, 2142, 7, 8, 0, 0, 2142, 2143, 7, 19, 0, 0, 2143, + 2144, 7, 24, 0, 0, 2144, 452, 1, 0, 0, 0, 2145, 2146, 7, 8, 0, 0, 2146, + 2147, 7, 12, 0, 0, 2147, 2148, 7, 12, 0, 0, 2148, 2149, 7, 4, 0, 0, 2149, + 2150, 7, 3, 0, 0, 2150, 2151, 7, 8, 0, 0, 2151, 2152, 7, 0, 0, 0, 2152, + 2153, 7, 19, 0, 0, 2153, 2154, 7, 4, 0, 0, 2154, 454, 1, 0, 0, 0, 2155, + 2156, 7, 8, 0, 0, 2156, 2157, 7, 12, 0, 0, 2157, 2158, 7, 12, 0, 0, 2158, + 2159, 7, 20, 0, 0, 2159, 2160, 7, 19, 0, 0, 2160, 2161, 7, 0, 0, 0, 2161, + 2162, 7, 1, 0, 0, 2162, 2163, 7, 11, 0, 0, 2163, 2164, 7, 4, 0, 0, 2164, + 456, 1, 0, 0, 0, 2165, 2166, 7, 8, 0, 0, 2166, 2167, 7, 12, 0, 0, 2167, + 2168, 7, 15, 0, 0, 2168, 2169, 7, 14, 0, 0, 2169, 2170, 7, 17, 0, 0, 2170, + 2171, 7, 19, 0, 0, 2171, 458, 1, 0, 0, 0, 2172, 2173, 7, 8, 0, 0, 2173, + 2174, 7, 13, 0, 0, 2174, 2175, 7, 2, 0, 0, 2175, 2176, 7, 17, 0, 0, 2176, + 2177, 7, 4, 0, 0, 2177, 2178, 7, 12, 0, 0, 2178, 2179, 7, 4, 0, 0, 2179, + 2180, 7, 13, 0, 0, 2180, 2181, 7, 19, 0, 0, 2181, 460, 1, 0, 0, 0, 2182, + 2183, 7, 8, 0, 0, 2183, 2184, 7, 13, 0, 0, 2184, 2185, 7, 3, 0, 0, 2185, + 2186, 7, 4, 0, 0, 2186, 2187, 7, 23, 0, 0, 2187, 462, 1, 0, 0, 0, 2188, + 2189, 7, 8, 0, 0, 2189, 2190, 7, 13, 0, 0, 2190, 2191, 7, 14, 0, 0, 2191, + 2192, 7, 20, 0, 0, 2192, 2193, 7, 19, 0, 0, 2193, 464, 1, 0, 0, 0, 2194, + 2195, 7, 8, 0, 0, 2195, 2196, 7, 13, 0, 0, 2196, 2197, 7, 15, 0, 0, 2197, + 2198, 7, 20, 0, 0, 2198, 2199, 7, 19, 0, 0, 2199, 466, 1, 0, 0, 0, 2200, + 2201, 7, 8, 0, 0, 2201, 2202, 7, 13, 0, 0, 2202, 2203, 7, 18, 0, 0, 2203, + 2204, 7, 4, 0, 0, 2204, 2205, 7, 17, 0, 0, 2205, 2206, 7, 19, 0, 0, 2206, + 468, 1, 0, 0, 0, 2207, 2208, 7, 8, 0, 0, 2208, 2209, 7, 13, 0, 0, 2209, + 2210, 7, 21, 0, 0, 2210, 2211, 7, 14, 0, 0, 2211, 2212, 7, 10, 0, 0, 2212, + 2213, 7, 4, 0, 0, 2213, 2214, 7, 17, 0, 0, 2214, 470, 1, 0, 0, 0, 2215, + 2216, 7, 8, 0, 0, 2216, 2217, 7, 18, 0, 0, 2217, 2218, 7, 14, 0, 0, 2218, + 2219, 7, 11, 0, 0, 2219, 2220, 7, 0, 0, 0, 2220, 2221, 7, 19, 0, 0, 2221, + 2222, 7, 8, 0, 0, 2222, 2223, 7, 14, 0, 0, 2223, 2224, 7, 13, 0, 0, 2224, + 472, 1, 0, 0, 0, 2225, 2226, 7, 8, 0, 0, 2226, 2227, 7, 19, 0, 0, 2227, + 2228, 7, 4, 0, 0, 2228, 2229, 7, 17, 0, 0, 2229, 2230, 7, 0, 0, 0, 2230, + 2231, 7, 19, 0, 0, 2231, 2232, 7, 4, 0, 0, 2232, 474, 1, 0, 0, 0, 2233, + 2234, 7, 10, 0, 0, 2234, 2235, 7, 4, 0, 0, 2235, 2236, 7, 24, 0, 0, 2236, + 476, 1, 0, 0, 0, 2237, 2238, 7, 11, 0, 0, 2238, 2239, 7, 0, 0, 0, 2239, + 2240, 7, 13, 0, 0, 2240, 2241, 7, 6, 0, 0, 2241, 2242, 7, 20, 0, 0, 2242, + 2243, 7, 0, 0, 0, 2243, 2244, 7, 6, 0, 0, 2244, 2245, 7, 4, 0, 0, 2245, + 478, 1, 0, 0, 0, 2246, 2247, 7, 11, 0, 0, 2247, 2248, 7, 0, 0, 0, 2248, + 2249, 7, 18, 0, 0, 2249, 2250, 7, 19, 0, 0, 2250, 480, 1, 0, 0, 0, 2251, + 2252, 7, 11, 0, 0, 2252, 2253, 7, 4, 0, 0, 2253, 2254, 7, 0, 0, 0, 2254, + 2255, 7, 21, 0, 0, 2255, 2256, 7, 4, 0, 0, 2256, 482, 1, 0, 0, 0, 2257, + 2258, 7, 11, 0, 0, 2258, 2259, 7, 4, 0, 0, 2259, 2260, 7, 21, 0, 0, 2260, + 2261, 7, 4, 0, 0, 2261, 2262, 7, 11, 0, 0, 2262, 484, 1, 0, 0, 0, 2263, + 2264, 7, 11, 0, 0, 2264, 2265, 7, 14, 0, 0, 2265, 2266, 7, 0, 0, 0, 2266, + 2267, 7, 3, 0, 0, 2267, 486, 1, 0, 0, 0, 2268, 2269, 7, 11, 0, 0, 2269, + 2270, 7, 14, 0, 0, 2270, 2271, 7, 14, 0, 0, 2271, 2272, 7, 15, 0, 0, 2272, + 488, 1, 0, 0, 0, 2273, 2274, 7, 12, 0, 0, 2274, 2275, 7, 0, 0, 0, 2275, + 2276, 7, 2, 0, 0, 2276, 2277, 7, 17, 0, 0, 2277, 2278, 7, 14, 0, 0, 2278, + 490, 1, 0, 0, 0, 2279, 2280, 7, 12, 0, 0, 2280, 2281, 7, 0, 0, 0, 2281, + 2282, 7, 15, 0, 0, 2282, 492, 1, 0, 0, 0, 2283, 2284, 7, 12, 0, 0, 2284, + 2285, 7, 0, 0, 0, 2285, 2286, 7, 19, 0, 0, 2286, 2287, 7, 2, 0, 0, 2287, + 2288, 7, 7, 0, 0, 2288, 494, 1, 0, 0, 0, 2289, 2290, 7, 10, 0, 0, 2290, + 2291, 7, 22, 0, 0, 2291, 2292, 5, 95, 0, 0, 2292, 2293, 7, 12, 0, 0, 2293, + 2294, 7, 0, 0, 0, 2294, 2295, 7, 19, 0, 0, 2295, 2296, 7, 2, 0, 0, 2296, + 2297, 7, 7, 0, 0, 2297, 2298, 5, 95, 0, 0, 2298, 2299, 7, 17, 0, 0, 2299, + 2300, 7, 4, 0, 0, 2300, 2301, 7, 2, 0, 0, 2301, 2302, 7, 14, 0, 0, 2302, + 2303, 7, 6, 0, 0, 2303, 2304, 7, 13, 0, 0, 2304, 2305, 7, 8, 0, 0, 2305, + 2306, 7, 25, 0, 0, 2306, 2307, 7, 4, 0, 0, 2307, 2308, 5, 95, 0, 0, 2308, + 2309, 7, 13, 0, 0, 2309, 2310, 7, 14, 0, 0, 2310, 2311, 7, 13, 0, 0, 2311, + 2312, 7, 17, 0, 0, 2312, 2313, 7, 4, 0, 0, 2313, 2314, 7, 18, 0, 0, 2314, + 2315, 7, 4, 0, 0, 2315, 2316, 7, 17, 0, 0, 2316, 2317, 7, 21, 0, 0, 2317, + 2318, 7, 4, 0, 0, 2318, 2319, 7, 3, 0, 0, 2319, 496, 1, 0, 0, 0, 2320, + 2321, 7, 12, 0, 0, 2321, 2322, 7, 0, 0, 0, 2322, 2323, 7, 19, 0, 0, 2323, + 2324, 7, 2, 0, 0, 2324, 2325, 7, 7, 0, 0, 2325, 2326, 7, 4, 0, 0, 2326, + 2327, 7, 3, 0, 0, 2327, 498, 1, 0, 0, 0, 2328, 2329, 7, 12, 0, 0, 2329, + 2330, 7, 0, 0, 0, 2330, 2331, 7, 19, 0, 0, 2331, 2332, 7, 4, 0, 0, 2332, + 2333, 7, 17, 0, 0, 2333, 2334, 7, 8, 0, 0, 2334, 2335, 7, 0, 0, 0, 2335, + 2336, 7, 11, 0, 0, 2336, 2337, 7, 8, 0, 0, 2337, 2338, 7, 25, 0, 0, 2338, + 2339, 7, 4, 0, 0, 2339, 2340, 7, 3, 0, 0, 2340, 500, 1, 0, 0, 0, 2341, + 2342, 7, 12, 0, 0, 2342, 2343, 7, 0, 0, 0, 2343, 2344, 7, 23, 0, 0, 2344, + 502, 1, 0, 0, 0, 2345, 2346, 7, 12, 0, 0, 2346, 2347, 7, 0, 0, 0, 2347, + 2348, 7, 23, 0, 0, 2348, 2349, 7, 21, 0, 0, 2349, 2350, 7, 0, 0, 0, 2350, + 2351, 7, 11, 0, 0, 2351, 2352, 7, 20, 0, 0, 2352, 2353, 7, 4, 0, 0, 2353, + 504, 1, 0, 0, 0, 2354, 2355, 7, 12, 0, 0, 2355, 2356, 7, 4, 0, 0, 2356, + 2357, 7, 0, 0, 0, 2357, 2358, 7, 18, 0, 0, 2358, 2359, 7, 20, 0, 0, 2359, + 2360, 7, 17, 0, 0, 2360, 2361, 7, 4, 0, 0, 2361, 2362, 7, 18, 0, 0, 2362, + 506, 1, 0, 0, 0, 2363, 2364, 7, 12, 0, 0, 2364, 2365, 7, 4, 0, 0, 2365, + 2366, 7, 18, 0, 0, 2366, 2367, 7, 18, 0, 0, 2367, 2368, 7, 0, 0, 0, 2368, + 2369, 7, 6, 0, 0, 2369, 2370, 7, 4, 0, 0, 2370, 508, 1, 0, 0, 0, 2371, + 2372, 7, 12, 0, 0, 2372, 2373, 7, 4, 0, 0, 2373, 2374, 7, 19, 0, 0, 2374, + 2375, 7, 0, 0, 0, 2375, 2376, 7, 3, 0, 0, 2376, 2377, 7, 0, 0, 0, 2377, + 2378, 7, 19, 0, 0, 2378, 2379, 7, 0, 0, 0, 2379, 510, 1, 0, 0, 0, 2380, + 2381, 7, 12, 0, 0, 2381, 2382, 7, 8, 0, 0, 2382, 2383, 7, 13, 0, 0, 2383, + 512, 1, 0, 0, 0, 2384, 2385, 7, 12, 0, 0, 2385, 2386, 7, 8, 0, 0, 2386, + 2387, 7, 13, 0, 0, 2387, 2388, 7, 21, 0, 0, 2388, 2389, 7, 0, 0, 0, 2389, + 2390, 7, 11, 0, 0, 2390, 2391, 7, 20, 0, 0, 2391, 2392, 7, 4, 0, 0, 2392, + 514, 1, 0, 0, 0, 2393, 2394, 7, 12, 0, 0, 2394, 2395, 7, 14, 0, 0, 2395, + 2396, 7, 3, 0, 0, 2396, 2397, 7, 4, 0, 0, 2397, 2398, 7, 11, 0, 0, 2398, + 516, 1, 0, 0, 0, 2399, 2400, 7, 12, 0, 0, 2400, 2401, 7, 14, 0, 0, 2401, + 2402, 7, 3, 0, 0, 2402, 2403, 7, 20, 0, 0, 2403, 2404, 7, 11, 0, 0, 2404, + 2405, 7, 4, 0, 0, 2405, 518, 1, 0, 0, 0, 2406, 2407, 7, 14, 0, 0, 2407, + 2408, 7, 13, 0, 0, 2408, 2409, 7, 11, 0, 0, 2409, 2410, 7, 24, 0, 0, 2410, + 520, 1, 0, 0, 0, 2411, 2412, 7, 14, 0, 0, 2412, 2413, 7, 20, 0, 0, 2413, + 2414, 7, 19, 0, 0, 2414, 522, 1, 0, 0, 0, 2415, 2416, 7, 14, 0, 0, 2416, + 2417, 7, 20, 0, 0, 2417, 2418, 7, 19, 0, 0, 2418, 2419, 7, 15, 0, 0, 2419, + 2420, 7, 20, 0, 0, 2420, 2421, 7, 19, 0, 0, 2421, 524, 1, 0, 0, 0, 2422, + 2423, 7, 14, 0, 0, 2423, 2424, 7, 21, 0, 0, 2424, 2425, 7, 4, 0, 0, 2425, + 2426, 7, 17, 0, 0, 2426, 2427, 7, 22, 0, 0, 2427, 2428, 7, 17, 0, 0, 2428, + 2429, 7, 8, 0, 0, 2429, 2430, 7, 19, 0, 0, 2430, 2431, 7, 4, 0, 0, 2431, + 526, 1, 0, 0, 0, 2432, 2433, 7, 15, 0, 0, 2433, 2434, 7, 0, 0, 0, 2434, + 2435, 7, 17, 0, 0, 2435, 2436, 7, 19, 0, 0, 2436, 2437, 7, 8, 0, 0, 2437, + 2438, 7, 19, 0, 0, 2438, 2439, 7, 8, 0, 0, 2439, 2440, 7, 14, 0, 0, 2440, + 2441, 7, 13, 0, 0, 2441, 2442, 7, 18, 0, 0, 2442, 528, 1, 0, 0, 0, 2443, + 2444, 7, 15, 0, 0, 2444, 2445, 7, 0, 0, 0, 2445, 2446, 7, 19, 0, 0, 2446, + 2447, 7, 19, 0, 0, 2447, 2448, 7, 4, 0, 0, 2448, 2449, 7, 17, 0, 0, 2449, + 2450, 7, 13, 0, 0, 2450, 530, 1, 0, 0, 0, 2451, 2452, 7, 15, 0, 0, 2452, + 2453, 7, 14, 0, 0, 2453, 2454, 7, 11, 0, 0, 2454, 2455, 7, 8, 0, 0, 2455, + 2456, 7, 2, 0, 0, 2456, 2457, 7, 8, 0, 0, 2457, 2458, 7, 4, 0, 0, 2458, + 2459, 7, 18, 0, 0, 2459, 532, 1, 0, 0, 0, 2460, 2461, 7, 15, 0, 0, 2461, + 2462, 7, 14, 0, 0, 2462, 2463, 7, 11, 0, 0, 2463, 2464, 7, 8, 0, 0, 2464, + 2465, 7, 2, 0, 0, 2465, 2466, 7, 24, 0, 0, 2466, 534, 1, 0, 0, 0, 2467, + 2468, 7, 15, 0, 0, 2468, 2469, 7, 17, 0, 0, 2469, 2470, 7, 8, 0, 0, 2470, + 2471, 7, 12, 0, 0, 2471, 2472, 7, 0, 0, 0, 2472, 2473, 7, 17, 0, 0, 2473, + 2474, 7, 24, 0, 0, 2474, 536, 1, 0, 0, 0, 2475, 2476, 7, 15, 0, 0, 2476, + 2477, 7, 17, 0, 0, 2477, 2478, 7, 8, 0, 0, 2478, 2479, 7, 21, 0, 0, 2479, + 2480, 7, 0, 0, 0, 2480, 2481, 7, 19, 0, 0, 2481, 2482, 7, 4, 0, 0, 2482, + 538, 1, 0, 0, 0, 2483, 2484, 7, 15, 0, 0, 2484, 2485, 7, 17, 0, 0, 2485, + 2486, 7, 8, 0, 0, 2486, 2487, 7, 21, 0, 0, 2487, 2488, 7, 8, 0, 0, 2488, + 2489, 7, 11, 0, 0, 2489, 2490, 7, 4, 0, 0, 2490, 2491, 7, 6, 0, 0, 2491, + 2492, 7, 4, 0, 0, 2492, 540, 1, 0, 0, 0, 2493, 2494, 7, 15, 0, 0, 2494, + 2495, 7, 17, 0, 0, 2495, 2496, 7, 8, 0, 0, 2496, 2497, 7, 21, 0, 0, 2497, + 2498, 7, 8, 0, 0, 2498, 2499, 7, 11, 0, 0, 2499, 2500, 7, 4, 0, 0, 2500, + 2501, 7, 6, 0, 0, 2501, 2502, 7, 4, 0, 0, 2502, 2503, 7, 18, 0, 0, 2503, + 542, 1, 0, 0, 0, 2504, 2505, 7, 15, 0, 0, 2505, 2506, 7, 17, 0, 0, 2506, + 2507, 7, 14, 0, 0, 2507, 2508, 7, 2, 0, 0, 2508, 2509, 7, 4, 0, 0, 2509, + 2510, 7, 3, 0, 0, 2510, 2511, 7, 20, 0, 0, 2511, 2512, 7, 17, 0, 0, 2512, + 2513, 7, 4, 0, 0, 2513, 544, 1, 0, 0, 0, 2514, 2515, 7, 15, 0, 0, 2515, + 2516, 7, 17, 0, 0, 2516, 2517, 7, 14, 0, 0, 2517, 2518, 7, 9, 0, 0, 2518, + 2519, 7, 4, 0, 0, 2519, 2520, 7, 2, 0, 0, 2520, 2521, 7, 19, 0, 0, 2521, + 546, 1, 0, 0, 0, 2522, 2523, 7, 15, 0, 0, 2523, 2524, 7, 20, 0, 0, 2524, + 2525, 7, 1, 0, 0, 2525, 2526, 7, 11, 0, 0, 2526, 2527, 7, 8, 0, 0, 2527, + 2528, 7, 2, 0, 0, 2528, 548, 1, 0, 0, 0, 2529, 2530, 7, 17, 0, 0, 2530, + 2531, 7, 0, 0, 0, 2531, 2532, 7, 8, 0, 0, 2532, 2533, 7, 18, 0, 0, 2533, + 2534, 7, 4, 0, 0, 2534, 550, 1, 0, 0, 0, 2535, 2536, 7, 17, 0, 0, 2536, + 2537, 7, 4, 0, 0, 2537, 2538, 7, 0, 0, 0, 2538, 2539, 7, 3, 0, 0, 2539, + 552, 1, 0, 0, 0, 2540, 2541, 7, 17, 0, 0, 2541, 2542, 7, 4, 0, 0, 2542, + 2543, 7, 5, 0, 0, 2543, 2544, 7, 4, 0, 0, 2544, 2545, 7, 17, 0, 0, 2545, + 2546, 7, 4, 0, 0, 2546, 2547, 7, 13, 0, 0, 2547, 2548, 7, 2, 0, 0, 2548, + 2549, 7, 4, 0, 0, 2549, 2550, 7, 18, 0, 0, 2550, 554, 1, 0, 0, 0, 2551, + 2552, 7, 17, 0, 0, 2552, 2553, 7, 4, 0, 0, 2553, 2554, 7, 12, 0, 0, 2554, + 2555, 7, 14, 0, 0, 2555, 2556, 7, 19, 0, 0, 2556, 2557, 7, 4, 0, 0, 2557, + 556, 1, 0, 0, 0, 2558, 2559, 7, 17, 0, 0, 2559, 2560, 7, 4, 0, 0, 2560, + 2561, 7, 12, 0, 0, 2561, 2562, 7, 14, 0, 0, 2562, 2563, 7, 21, 0, 0, 2563, + 2564, 7, 4, 0, 0, 2564, 558, 1, 0, 0, 0, 2565, 2566, 7, 17, 0, 0, 2566, + 2567, 7, 4, 0, 0, 2567, 2568, 7, 13, 0, 0, 2568, 2569, 7, 0, 0, 0, 2569, + 2570, 7, 12, 0, 0, 2570, 2571, 7, 4, 0, 0, 2571, 560, 1, 0, 0, 0, 2572, + 2573, 7, 17, 0, 0, 2573, 2574, 7, 4, 0, 0, 2574, 2575, 7, 15, 0, 0, 2575, + 2576, 7, 4, 0, 0, 2576, 2577, 7, 0, 0, 0, 2577, 2578, 7, 19, 0, 0, 2578, + 562, 1, 0, 0, 0, 2579, 2580, 7, 17, 0, 0, 2580, 2581, 7, 4, 0, 0, 2581, + 2582, 7, 15, 0, 0, 2582, 2583, 7, 4, 0, 0, 2583, 2584, 7, 0, 0, 0, 2584, + 2585, 7, 19, 0, 0, 2585, 2586, 7, 0, 0, 0, 2586, 2587, 7, 1, 0, 0, 2587, + 2588, 7, 11, 0, 0, 2588, 2589, 7, 4, 0, 0, 2589, 564, 1, 0, 0, 0, 2590, + 2591, 7, 17, 0, 0, 2591, 2592, 7, 4, 0, 0, 2592, 2593, 7, 15, 0, 0, 2593, + 2594, 7, 11, 0, 0, 2594, 2595, 7, 0, 0, 0, 2595, 2596, 7, 2, 0, 0, 2596, + 2597, 7, 4, 0, 0, 2597, 2598, 5, 95, 0, 0, 2598, 2599, 7, 5, 0, 0, 2599, + 2600, 7, 8, 0, 0, 2600, 2601, 7, 4, 0, 0, 2601, 2602, 7, 11, 0, 0, 2602, + 2603, 7, 3, 0, 0, 2603, 2604, 7, 18, 0, 0, 2604, 566, 1, 0, 0, 0, 2605, + 2606, 7, 17, 0, 0, 2606, 2607, 7, 4, 0, 0, 2607, 2608, 7, 15, 0, 0, 2608, + 2609, 7, 11, 0, 0, 2609, 2610, 7, 8, 0, 0, 2610, 2611, 7, 2, 0, 0, 2611, + 2612, 7, 0, 0, 0, 2612, 568, 1, 0, 0, 0, 2613, 2614, 7, 17, 0, 0, 2614, + 2615, 7, 4, 0, 0, 2615, 2616, 7, 15, 0, 0, 2616, 2617, 7, 14, 0, 0, 2617, + 2618, 7, 17, 0, 0, 2618, 2619, 7, 19, 0, 0, 2619, 570, 1, 0, 0, 0, 2620, + 2621, 7, 17, 0, 0, 2621, 2622, 7, 4, 0, 0, 2622, 2623, 7, 18, 0, 0, 2623, + 2624, 7, 19, 0, 0, 2624, 2625, 7, 17, 0, 0, 2625, 2626, 7, 8, 0, 0, 2626, + 2627, 7, 2, 0, 0, 2627, 2628, 7, 19, 0, 0, 2628, 572, 1, 0, 0, 0, 2629, + 2630, 7, 17, 0, 0, 2630, 2631, 7, 4, 0, 0, 2631, 2632, 7, 18, 0, 0, 2632, + 2633, 7, 19, 0, 0, 2633, 2634, 7, 17, 0, 0, 2634, 2635, 7, 8, 0, 0, 2635, + 2636, 7, 2, 0, 0, 2636, 2637, 7, 19, 0, 0, 2637, 2638, 7, 8, 0, 0, 2638, + 2639, 7, 14, 0, 0, 2639, 2640, 7, 13, 0, 0, 2640, 574, 1, 0, 0, 0, 2641, + 2642, 7, 17, 0, 0, 2642, 2643, 7, 4, 0, 0, 2643, 2644, 7, 19, 0, 0, 2644, + 2645, 7, 20, 0, 0, 2645, 2646, 7, 17, 0, 0, 2646, 2647, 7, 13, 0, 0, 2647, + 2648, 7, 18, 0, 0, 2648, 576, 1, 0, 0, 0, 2649, 2650, 7, 17, 0, 0, 2650, + 2651, 7, 4, 0, 0, 2651, 2652, 7, 19, 0, 0, 2652, 2653, 7, 20, 0, 0, 2653, + 2654, 7, 17, 0, 0, 2654, 2655, 7, 13, 0, 0, 2655, 578, 1, 0, 0, 0, 2656, + 2657, 7, 17, 0, 0, 2657, 2658, 7, 4, 0, 0, 2658, 2659, 7, 21, 0, 0, 2659, + 2660, 7, 14, 0, 0, 2660, 2661, 7, 10, 0, 0, 2661, 2662, 7, 4, 0, 0, 2662, + 580, 1, 0, 0, 0, 2663, 2664, 7, 17, 0, 0, 2664, 2665, 7, 14, 0, 0, 2665, + 2666, 7, 11, 0, 0, 2666, 2667, 7, 11, 0, 0, 2667, 2668, 7, 1, 0, 0, 2668, + 2669, 7, 0, 0, 0, 2669, 2670, 7, 2, 0, 0, 2670, 2671, 7, 10, 0, 0, 2671, + 582, 1, 0, 0, 0, 2672, 2673, 7, 17, 0, 0, 2673, 2674, 7, 14, 0, 0, 2674, + 2675, 7, 22, 0, 0, 2675, 584, 1, 0, 0, 0, 2676, 2677, 7, 17, 0, 0, 2677, + 2678, 7, 20, 0, 0, 2678, 2679, 7, 13, 0, 0, 2679, 586, 1, 0, 0, 0, 2680, + 2681, 7, 18, 0, 0, 2681, 2682, 7, 0, 0, 0, 2682, 2683, 7, 5, 0, 0, 2683, + 2684, 7, 4, 0, 0, 2684, 2685, 5, 95, 0, 0, 2685, 2686, 7, 2, 0, 0, 2686, + 2687, 7, 0, 0, 0, 2687, 2688, 7, 18, 0, 0, 2688, 2689, 7, 19, 0, 0, 2689, + 588, 1, 0, 0, 0, 2690, 2691, 7, 18, 0, 0, 2691, 2692, 7, 2, 0, 0, 2692, + 2693, 7, 7, 0, 0, 2693, 2694, 7, 4, 0, 0, 2694, 2695, 7, 12, 0, 0, 2695, + 2696, 7, 0, 0, 0, 2696, 590, 1, 0, 0, 0, 2697, 2698, 7, 18, 0, 0, 2698, + 2699, 7, 4, 0, 0, 2699, 2700, 7, 0, 0, 0, 2700, 2701, 7, 17, 0, 0, 2701, + 2702, 7, 2, 0, 0, 2702, 2703, 7, 7, 0, 0, 2703, 592, 1, 0, 0, 0, 2704, + 2705, 7, 18, 0, 0, 2705, 2706, 7, 4, 0, 0, 2706, 2707, 7, 2, 0, 0, 2707, + 2708, 7, 20, 0, 0, 2708, 2709, 7, 17, 0, 0, 2709, 2710, 7, 8, 0, 0, 2710, + 2711, 7, 19, 0, 0, 2711, 2712, 7, 24, 0, 0, 2712, 594, 1, 0, 0, 0, 2713, + 2714, 7, 18, 0, 0, 2714, 2715, 7, 4, 0, 0, 2715, 2716, 7, 16, 0, 0, 2716, + 2717, 7, 20, 0, 0, 2717, 2718, 7, 4, 0, 0, 2718, 2719, 7, 13, 0, 0, 2719, + 2720, 7, 2, 0, 0, 2720, 2721, 7, 4, 0, 0, 2721, 596, 1, 0, 0, 0, 2722, + 2723, 7, 18, 0, 0, 2723, 2724, 7, 4, 0, 0, 2724, 2725, 7, 19, 0, 0, 2725, + 2726, 7, 18, 0, 0, 2726, 598, 1, 0, 0, 0, 2727, 2728, 7, 18, 0, 0, 2728, + 2729, 7, 4, 0, 0, 2729, 2730, 7, 19, 0, 0, 2730, 600, 1, 0, 0, 0, 2731, + 2732, 7, 18, 0, 0, 2732, 2733, 7, 7, 0, 0, 2733, 2734, 7, 14, 0, 0, 2734, + 2735, 7, 22, 0, 0, 2735, 602, 1, 0, 0, 0, 2736, 2737, 7, 18, 0, 0, 2737, + 2738, 7, 13, 0, 0, 2738, 2739, 7, 0, 0, 0, 2739, 2740, 7, 15, 0, 0, 2740, + 2741, 7, 18, 0, 0, 2741, 2742, 7, 7, 0, 0, 2742, 2743, 7, 14, 0, 0, 2743, + 2744, 7, 19, 0, 0, 2744, 604, 1, 0, 0, 0, 2745, 2746, 7, 18, 0, 0, 2746, + 2747, 7, 14, 0, 0, 2747, 2748, 7, 20, 0, 0, 2748, 2749, 7, 17, 0, 0, 2749, + 2750, 7, 2, 0, 0, 2750, 2751, 7, 4, 0, 0, 2751, 606, 1, 0, 0, 0, 2752, + 2753, 7, 18, 0, 0, 2753, 2754, 7, 16, 0, 0, 2754, 2755, 7, 11, 0, 0, 2755, + 608, 1, 0, 0, 0, 2756, 2757, 7, 18, 0, 0, 2757, 2758, 7, 19, 0, 0, 2758, + 2759, 7, 0, 0, 0, 2759, 2760, 7, 1, 0, 0, 2760, 2761, 7, 11, 0, 0, 2761, + 2762, 7, 4, 0, 0, 2762, 610, 1, 0, 0, 0, 2763, 2764, 7, 18, 0, 0, 2764, + 2765, 7, 19, 0, 0, 2765, 2766, 7, 0, 0, 0, 2766, 2767, 7, 17, 0, 0, 2767, + 2768, 7, 19, 0, 0, 2768, 612, 1, 0, 0, 0, 2769, 2770, 7, 18, 0, 0, 2770, + 2771, 7, 19, 0, 0, 2771, 2772, 7, 0, 0, 0, 2772, 2773, 7, 19, 0, 0, 2773, + 2774, 7, 8, 0, 0, 2774, 2775, 7, 2, 0, 0, 2775, 2776, 5, 95, 0, 0, 2776, + 2777, 7, 3, 0, 0, 2777, 2778, 7, 4, 0, 0, 2778, 2779, 7, 18, 0, 0, 2779, + 2780, 7, 2, 0, 0, 2780, 2781, 7, 17, 0, 0, 2781, 2782, 7, 8, 0, 0, 2782, + 2783, 7, 1, 0, 0, 2783, 2784, 7, 4, 0, 0, 2784, 614, 1, 0, 0, 0, 2785, + 2786, 7, 18, 0, 0, 2786, 2787, 7, 19, 0, 0, 2787, 2788, 7, 14, 0, 0, 2788, + 2789, 7, 17, 0, 0, 2789, 2790, 7, 4, 0, 0, 2790, 2791, 7, 3, 0, 0, 2791, + 616, 1, 0, 0, 0, 2792, 2793, 7, 18, 0, 0, 2793, 2794, 7, 19, 0, 0, 2794, + 2795, 7, 14, 0, 0, 2795, 2796, 7, 17, 0, 0, 2796, 2797, 7, 8, 0, 0, 2797, + 2798, 7, 13, 0, 0, 2798, 2799, 7, 6, 0, 0, 2799, 618, 1, 0, 0, 0, 2800, + 2801, 7, 18, 0, 0, 2801, 2802, 7, 19, 0, 0, 2802, 2803, 7, 17, 0, 0, 2803, + 2804, 7, 8, 0, 0, 2804, 2805, 7, 2, 0, 0, 2805, 2806, 7, 19, 0, 0, 2806, + 620, 1, 0, 0, 0, 2807, 2808, 7, 19, 0, 0, 2808, 2809, 7, 0, 0, 0, 2809, + 2810, 7, 1, 0, 0, 2810, 2811, 7, 11, 0, 0, 2811, 2812, 7, 4, 0, 0, 2812, + 622, 1, 0, 0, 0, 2813, 2814, 7, 19, 0, 0, 2814, 2815, 7, 0, 0, 0, 2815, + 2816, 7, 1, 0, 0, 2816, 2817, 7, 11, 0, 0, 2817, 2818, 7, 4, 0, 0, 2818, + 2819, 7, 18, 0, 0, 2819, 624, 1, 0, 0, 0, 2820, 2821, 7, 19, 0, 0, 2821, + 2822, 7, 0, 0, 0, 2822, 2823, 7, 17, 0, 0, 2823, 2824, 7, 6, 0, 0, 2824, + 2825, 7, 4, 0, 0, 2825, 2826, 7, 19, 0, 0, 2826, 626, 1, 0, 0, 0, 2827, + 2828, 7, 19, 0, 0, 2828, 2829, 7, 4, 0, 0, 2829, 2830, 7, 12, 0, 0, 2830, + 2831, 7, 15, 0, 0, 2831, 628, 1, 0, 0, 0, 2832, 2833, 7, 19, 0, 0, 2833, + 2834, 7, 4, 0, 0, 2834, 2835, 7, 12, 0, 0, 2835, 2836, 7, 15, 0, 0, 2836, + 2837, 7, 14, 0, 0, 2837, 2838, 7, 17, 0, 0, 2838, 2839, 7, 0, 0, 0, 2839, + 2840, 7, 17, 0, 0, 2840, 2841, 7, 24, 0, 0, 2841, 630, 1, 0, 0, 0, 2842, + 2843, 7, 19, 0, 0, 2843, 2844, 7, 17, 0, 0, 2844, 2845, 7, 0, 0, 0, 2845, + 2846, 7, 13, 0, 0, 2846, 2847, 7, 18, 0, 0, 2847, 2848, 7, 0, 0, 0, 2848, + 2849, 7, 2, 0, 0, 2849, 2850, 7, 19, 0, 0, 2850, 2851, 7, 8, 0, 0, 2851, + 2852, 7, 14, 0, 0, 2852, 2853, 7, 13, 0, 0, 2853, 632, 1, 0, 0, 0, 2854, + 2855, 7, 19, 0, 0, 2855, 2856, 7, 17, 0, 0, 2856, 2857, 7, 0, 0, 0, 2857, + 2858, 7, 13, 0, 0, 2858, 2859, 7, 18, 0, 0, 2859, 2860, 7, 5, 0, 0, 2860, + 2861, 7, 14, 0, 0, 2861, 2862, 7, 17, 0, 0, 2862, 2863, 7, 12, 0, 0, 2863, + 634, 1, 0, 0, 0, 2864, 2865, 7, 19, 0, 0, 2865, 2866, 7, 17, 0, 0, 2866, + 2867, 7, 20, 0, 0, 2867, 2868, 7, 13, 0, 0, 2868, 2869, 7, 2, 0, 0, 2869, + 2870, 7, 0, 0, 0, 2870, 2871, 7, 19, 0, 0, 2871, 2872, 7, 4, 0, 0, 2872, + 636, 1, 0, 0, 0, 2873, 2874, 7, 19, 0, 0, 2874, 2875, 7, 24, 0, 0, 2875, + 2876, 7, 15, 0, 0, 2876, 2877, 7, 4, 0, 0, 2877, 638, 1, 0, 0, 0, 2878, + 2879, 7, 20, 0, 0, 2879, 2880, 7, 13, 0, 0, 2880, 2881, 7, 3, 0, 0, 2881, + 2882, 7, 17, 0, 0, 2882, 2883, 7, 14, 0, 0, 2883, 2884, 7, 15, 0, 0, 2884, + 640, 1, 0, 0, 0, 2885, 2886, 7, 20, 0, 0, 2886, 2887, 7, 13, 0, 0, 2887, + 2888, 7, 8, 0, 0, 2888, 2889, 7, 16, 0, 0, 2889, 2890, 7, 20, 0, 0, 2890, + 2891, 7, 4, 0, 0, 2891, 642, 1, 0, 0, 0, 2892, 2893, 7, 20, 0, 0, 2893, + 2894, 7, 13, 0, 0, 2894, 2895, 7, 10, 0, 0, 2895, 2896, 7, 13, 0, 0, 2896, + 2897, 7, 14, 0, 0, 2897, 2898, 7, 22, 0, 0, 2898, 2899, 7, 13, 0, 0, 2899, + 644, 1, 0, 0, 0, 2900, 2901, 7, 20, 0, 0, 2901, 2902, 7, 13, 0, 0, 2902, + 2903, 7, 19, 0, 0, 2903, 2904, 7, 8, 0, 0, 2904, 2905, 7, 11, 0, 0, 2905, + 646, 1, 0, 0, 0, 2906, 2907, 7, 20, 0, 0, 2907, 2908, 7, 15, 0, 0, 2908, + 2909, 7, 3, 0, 0, 2909, 2910, 7, 0, 0, 0, 2910, 2911, 7, 19, 0, 0, 2911, + 2912, 7, 4, 0, 0, 2912, 648, 1, 0, 0, 0, 2913, 2914, 7, 21, 0, 0, 2914, + 2915, 7, 0, 0, 0, 2915, 2916, 7, 11, 0, 0, 2916, 2917, 7, 20, 0, 0, 2917, + 2918, 7, 4, 0, 0, 2918, 2919, 7, 18, 0, 0, 2919, 650, 1, 0, 0, 0, 2920, + 2921, 7, 21, 0, 0, 2921, 2922, 7, 4, 0, 0, 2922, 2923, 7, 2, 0, 0, 2923, + 2924, 7, 19, 0, 0, 2924, 2925, 7, 14, 0, 0, 2925, 2926, 7, 17, 0, 0, 2926, + 652, 1, 0, 0, 0, 2927, 2928, 7, 21, 0, 0, 2928, 2929, 7, 8, 0, 0, 2929, + 2930, 7, 4, 0, 0, 2930, 2931, 7, 22, 0, 0, 2931, 654, 1, 0, 0, 0, 2932, + 2933, 7, 21, 0, 0, 2933, 2934, 7, 8, 0, 0, 2934, 2935, 7, 4, 0, 0, 2935, + 2936, 7, 22, 0, 0, 2936, 2937, 7, 18, 0, 0, 2937, 656, 1, 0, 0, 0, 2938, + 2939, 7, 21, 0, 0, 2939, 2940, 7, 14, 0, 0, 2940, 2941, 7, 11, 0, 0, 2941, + 2942, 7, 0, 0, 0, 2942, 2943, 7, 19, 0, 0, 2943, 2944, 7, 8, 0, 0, 2944, + 2945, 7, 11, 0, 0, 2945, 2946, 7, 4, 0, 0, 2946, 658, 1, 0, 0, 0, 2947, + 2948, 7, 22, 0, 0, 2948, 2949, 7, 4, 0, 0, 2949, 2950, 7, 8, 0, 0, 2950, + 2951, 7, 6, 0, 0, 2951, 2952, 7, 7, 0, 0, 2952, 2953, 7, 19, 0, 0, 2953, + 660, 1, 0, 0, 0, 2954, 2955, 7, 22, 0, 0, 2955, 2956, 7, 7, 0, 0, 2956, + 2957, 7, 8, 0, 0, 2957, 2958, 7, 11, 0, 0, 2958, 2959, 7, 4, 0, 0, 2959, + 662, 1, 0, 0, 0, 2960, 2961, 7, 22, 0, 0, 2961, 2962, 7, 17, 0, 0, 2962, + 2963, 7, 8, 0, 0, 2963, 2964, 7, 19, 0, 0, 2964, 2965, 7, 4, 0, 0, 2965, + 664, 1, 0, 0, 0, 2966, 2967, 7, 25, 0, 0, 2967, 2968, 7, 14, 0, 0, 2968, + 2969, 7, 13, 0, 0, 2969, 2970, 7, 4, 0, 0, 2970, 666, 1, 0, 0, 0, 2971, + 2972, 7, 3, 0, 0, 2972, 2973, 7, 4, 0, 0, 2973, 2974, 7, 18, 0, 0, 2974, + 2975, 7, 2, 0, 0, 2975, 2976, 7, 17, 0, 0, 2976, 2977, 7, 8, 0, 0, 2977, + 2978, 7, 15, 0, 0, 2978, 2979, 7, 19, 0, 0, 2979, 2980, 7, 14, 0, 0, 2980, + 2981, 7, 17, 0, 0, 2981, 668, 1, 0, 0, 0, 2982, 2983, 7, 8, 0, 0, 2983, + 2984, 7, 13, 0, 0, 2984, 2985, 7, 19, 0, 0, 2985, 2986, 7, 4, 0, 0, 2986, + 2987, 7, 17, 0, 0, 2987, 2988, 7, 11, 0, 0, 2988, 2989, 7, 4, 0, 0, 2989, + 2990, 7, 0, 0, 0, 2990, 2991, 7, 21, 0, 0, 2991, 2992, 7, 4, 0, 0, 2992, + 670, 1, 0, 0, 0, 2993, 2994, 7, 13, 0, 0, 2994, 2995, 7, 20, 0, 0, 2995, + 2996, 7, 11, 0, 0, 2996, 2997, 7, 11, 0, 0, 2997, 2998, 5, 95, 0, 0, 2998, + 2999, 7, 5, 0, 0, 2999, 3000, 7, 8, 0, 0, 3000, 3001, 7, 11, 0, 0, 3001, + 3002, 7, 19, 0, 0, 3002, 3003, 7, 4, 0, 0, 3003, 3004, 7, 17, 0, 0, 3004, + 3005, 7, 4, 0, 0, 3005, 3006, 7, 3, 0, 0, 3006, 672, 1, 0, 0, 0, 3007, + 3008, 7, 15, 0, 0, 3008, 3009, 7, 0, 0, 0, 3009, 3010, 7, 17, 0, 0, 3010, + 3011, 7, 4, 0, 0, 3011, 3012, 7, 13, 0, 0, 3012, 3013, 7, 19, 0, 0, 3013, + 674, 1, 0, 0, 0, 3014, 3015, 7, 13, 0, 0, 3015, 3016, 7, 4, 0, 0, 3016, + 3017, 7, 22, 0, 0, 3017, 676, 1, 0, 0, 0, 3018, 3019, 7, 4, 0, 0, 3019, + 3020, 7, 13, 0, 0, 3020, 3021, 7, 3, 0, 0, 3021, 678, 1, 0, 0, 0, 3022, + 3023, 7, 2, 0, 0, 3023, 3024, 7, 0, 0, 0, 3024, 3025, 7, 18, 0, 0, 3025, + 3026, 7, 4, 0, 0, 3026, 680, 1, 0, 0, 0, 3027, 3028, 7, 22, 0, 0, 3028, + 3029, 7, 7, 0, 0, 3029, 3030, 7, 4, 0, 0, 3030, 3031, 7, 13, 0, 0, 3031, + 682, 1, 0, 0, 0, 3032, 3033, 7, 19, 0, 0, 3033, 3034, 7, 7, 0, 0, 3034, + 3035, 7, 4, 0, 0, 3035, 3036, 7, 13, 0, 0, 3036, 684, 1, 0, 0, 0, 3037, + 3038, 7, 4, 0, 0, 3038, 3039, 7, 11, 0, 0, 3039, 3040, 7, 18, 0, 0, 3040, + 3041, 7, 4, 0, 0, 3041, 686, 1, 0, 0, 0, 3042, 3043, 7, 2, 0, 0, 3043, + 3044, 7, 0, 0, 0, 3044, 3045, 7, 18, 0, 0, 3045, 3046, 7, 19, 0, 0, 3046, + 688, 1, 0, 0, 0, 3047, 3048, 7, 4, 0, 0, 3048, 3049, 7, 23, 0, 0, 3049, + 3050, 7, 19, 0, 0, 3050, 3051, 7, 17, 0, 0, 3051, 3052, 7, 0, 0, 0, 3052, + 3053, 7, 2, 0, 0, 3053, 3054, 7, 19, 0, 0, 3054, 690, 1, 0, 0, 0, 3055, + 3056, 7, 2, 0, 0, 3056, 3057, 7, 14, 0, 0, 3057, 3058, 7, 11, 0, 0, 3058, + 3059, 7, 11, 0, 0, 3059, 3060, 7, 0, 0, 0, 3060, 3061, 7, 19, 0, 0, 3061, + 3062, 7, 4, 0, 0, 3062, 692, 1, 0, 0, 0, 3063, 3064, 7, 8, 0, 0, 3064, + 3065, 7, 5, 0, 0, 3065, 694, 1, 0, 0, 0, 3066, 3067, 7, 6, 0, 0, 3067, + 3068, 7, 17, 0, 0, 3068, 3069, 7, 14, 0, 0, 3069, 3070, 7, 20, 0, 0, 3070, + 3071, 7, 15, 0, 0, 3071, 3072, 7, 8, 0, 0, 3072, 3073, 7, 13, 0, 0, 3073, + 3074, 7, 6, 0, 0, 3074, 696, 1, 0, 0, 0, 3075, 3076, 7, 7, 0, 0, 3076, + 3077, 7, 0, 0, 0, 3077, 3078, 7, 21, 0, 0, 3078, 3079, 7, 8, 0, 0, 3079, + 3080, 7, 13, 0, 0, 3080, 3081, 7, 6, 0, 0, 3081, 698, 1, 0, 0, 0, 3082, + 3083, 7, 6, 0, 0, 3083, 3084, 7, 17, 0, 0, 3084, 3085, 7, 14, 0, 0, 3085, + 3086, 7, 20, 0, 0, 3086, 3087, 7, 15, 0, 0, 3087, 700, 1, 0, 0, 0, 3088, + 3089, 7, 17, 0, 0, 3089, 3090, 7, 14, 0, 0, 3090, 3091, 7, 11, 0, 0, 3091, + 3092, 7, 11, 0, 0, 3092, 3093, 7, 20, 0, 0, 3093, 3094, 7, 15, 0, 0, 3094, + 702, 1, 0, 0, 0, 3095, 3096, 7, 2, 0, 0, 3096, 3097, 7, 20, 0, 0, 3097, + 3098, 7, 1, 0, 0, 3098, 3099, 7, 4, 0, 0, 3099, 704, 1, 0, 0, 0, 3100, + 3101, 7, 7, 0, 0, 3101, 3102, 7, 0, 0, 0, 3102, 3103, 7, 18, 0, 0, 3103, + 3104, 7, 7, 0, 0, 3104, 706, 1, 0, 0, 0, 3105, 3106, 7, 15, 0, 0, 3106, + 3107, 7, 17, 0, 0, 3107, 3108, 7, 14, 0, 0, 3108, 3109, 7, 19, 0, 0, 3109, + 3110, 7, 14, 0, 0, 3110, 708, 1, 0, 0, 0, 3111, 3112, 7, 15, 0, 0, 3112, + 3113, 7, 0, 0, 0, 3113, 3114, 7, 17, 0, 0, 3114, 3115, 7, 19, 0, 0, 3115, + 3116, 7, 8, 0, 0, 3116, 3117, 7, 19, 0, 0, 3117, 3118, 7, 8, 0, 0, 3118, + 3119, 7, 14, 0, 0, 3119, 3120, 7, 13, 0, 0, 3120, 710, 1, 0, 0, 0, 3121, + 3122, 7, 8, 0, 0, 3122, 3123, 7, 6, 0, 0, 3123, 3124, 7, 13, 0, 0, 3124, + 3125, 7, 14, 0, 0, 3125, 3126, 7, 17, 0, 0, 3126, 3127, 7, 4, 0, 0, 3127, + 712, 1, 0, 0, 0, 3128, 3129, 7, 17, 0, 0, 3129, 3130, 7, 4, 0, 0, 3130, + 3131, 7, 18, 0, 0, 3131, 3132, 7, 15, 0, 0, 3132, 3133, 7, 4, 0, 0, 3133, + 3134, 7, 2, 0, 0, 3134, 3135, 7, 19, 0, 0, 3135, 714, 1, 0, 0, 0, 3136, + 3137, 7, 17, 0, 0, 3137, 3138, 7, 14, 0, 0, 3138, 3139, 7, 22, 0, 0, 3139, + 3140, 7, 18, 0, 0, 3140, 716, 1, 0, 0, 0, 3141, 3142, 7, 14, 0, 0, 3142, + 3143, 7, 21, 0, 0, 3143, 3144, 7, 4, 0, 0, 3144, 3145, 7, 17, 0, 0, 3145, + 718, 1, 0, 0, 0, 3146, 3147, 7, 1, 0, 0, 3147, 3148, 7, 4, 0, 0, 3148, + 3149, 7, 19, 0, 0, 3149, 3150, 7, 22, 0, 0, 3150, 3151, 7, 4, 0, 0, 3151, + 3152, 7, 4, 0, 0, 3152, 3153, 7, 13, 0, 0, 3153, 720, 1, 0, 0, 0, 3154, + 3155, 7, 20, 0, 0, 3155, 3156, 7, 13, 0, 0, 3156, 3157, 7, 1, 0, 0, 3157, + 3158, 7, 14, 0, 0, 3158, 3159, 7, 20, 0, 0, 3159, 3160, 7, 13, 0, 0, 3160, + 3161, 7, 3, 0, 0, 3161, 3162, 7, 4, 0, 0, 3162, 3163, 7, 3, 0, 0, 3163, + 722, 1, 0, 0, 0, 3164, 3165, 7, 2, 0, 0, 3165, 3166, 7, 20, 0, 0, 3166, + 3167, 7, 17, 0, 0, 3167, 3168, 7, 17, 0, 0, 3168, 3169, 7, 4, 0, 0, 3169, + 3170, 7, 13, 0, 0, 3170, 3171, 7, 19, 0, 0, 3171, 724, 1, 0, 0, 0, 3172, + 3173, 7, 15, 0, 0, 3173, 3174, 7, 17, 0, 0, 3174, 3175, 7, 4, 0, 0, 3175, + 3176, 7, 2, 0, 0, 3176, 3177, 7, 4, 0, 0, 3177, 3178, 7, 3, 0, 0, 3178, + 3179, 7, 8, 0, 0, 3179, 3180, 7, 13, 0, 0, 3180, 3181, 7, 6, 0, 0, 3181, + 726, 1, 0, 0, 0, 3182, 3183, 7, 5, 0, 0, 3183, 3184, 7, 14, 0, 0, 3184, + 3185, 7, 11, 0, 0, 3185, 3186, 7, 11, 0, 0, 3186, 3187, 7, 14, 0, 0, 3187, + 3188, 7, 22, 0, 0, 3188, 3189, 7, 8, 0, 0, 3189, 3190, 7, 13, 0, 0, 3190, + 3191, 7, 6, 0, 0, 3191, 728, 1, 0, 0, 0, 3192, 3193, 7, 13, 0, 0, 3193, + 3194, 7, 0, 0, 0, 3194, 3195, 7, 19, 0, 0, 3195, 3196, 7, 20, 0, 0, 3196, + 3197, 7, 17, 0, 0, 3197, 3198, 7, 0, 0, 0, 3198, 3199, 7, 11, 0, 0, 3199, + 730, 1, 0, 0, 0, 3200, 3201, 7, 16, 0, 0, 3201, 3202, 7, 20, 0, 0, 3202, + 3203, 7, 0, 0, 0, 3203, 3204, 7, 11, 0, 0, 3204, 3205, 7, 8, 0, 0, 3205, + 3206, 7, 5, 0, 0, 3206, 3207, 7, 24, 0, 0, 3207, 732, 1, 0, 0, 0, 3208, + 3209, 7, 3, 0, 0, 3209, 3210, 7, 4, 0, 0, 3210, 3211, 7, 5, 0, 0, 3211, + 3212, 7, 0, 0, 0, 3212, 3213, 7, 20, 0, 0, 3213, 3214, 7, 11, 0, 0, 3214, + 3215, 7, 19, 0, 0, 3215, 734, 1, 0, 0, 0, 3216, 3217, 7, 18, 0, 0, 3217, + 3218, 7, 11, 0, 0, 3218, 3219, 7, 0, 0, 0, 3219, 3220, 7, 18, 0, 0, 3220, + 3221, 7, 7, 0, 0, 3221, 736, 1, 0, 0, 0, 3222, 3223, 7, 12, 0, 0, 3223, + 3224, 7, 0, 0, 0, 3224, 3225, 7, 19, 0, 0, 3225, 3226, 7, 2, 0, 0, 3226, + 3227, 7, 7, 0, 0, 3227, 3228, 5, 95, 0, 0, 3228, 3229, 7, 17, 0, 0, 3229, + 3230, 7, 4, 0, 0, 3230, 3231, 7, 2, 0, 0, 3231, 3232, 7, 14, 0, 0, 3232, + 3233, 7, 6, 0, 0, 3233, 3234, 7, 13, 0, 0, 3234, 3235, 7, 8, 0, 0, 3235, + 3236, 7, 25, 0, 0, 3236, 3237, 7, 4, 0, 0, 3237, 738, 1, 0, 0, 0, 3238, + 3239, 7, 3, 0, 0, 3239, 3240, 7, 4, 0, 0, 3240, 3241, 7, 5, 0, 0, 3241, + 3242, 7, 8, 0, 0, 3242, 3243, 7, 13, 0, 0, 3243, 3244, 7, 4, 0, 0, 3244, + 740, 1, 0, 0, 0, 3245, 3246, 7, 11, 0, 0, 3246, 3247, 7, 14, 0, 0, 3247, + 3248, 7, 14, 0, 0, 3248, 3249, 7, 10, 0, 0, 3249, 3250, 7, 20, 0, 0, 3250, + 3251, 7, 15, 0, 0, 3251, 742, 1, 0, 0, 0, 3252, 3253, 7, 22, 0, 0, 3253, + 3254, 7, 7, 0, 0, 3254, 3255, 7, 4, 0, 0, 3255, 3256, 7, 17, 0, 0, 3256, + 3257, 7, 4, 0, 0, 3257, 744, 1, 0, 0, 0, 3258, 3259, 7, 22, 0, 0, 3259, + 3260, 7, 8, 0, 0, 3260, 3261, 7, 13, 0, 0, 3261, 3262, 7, 3, 0, 0, 3262, + 3263, 7, 14, 0, 0, 3263, 3264, 7, 22, 0, 0, 3264, 746, 1, 0, 0, 0, 3265, + 3266, 7, 19, 0, 0, 3266, 3267, 7, 14, 0, 0, 3267, 748, 1, 0, 0, 0, 3268, + 3269, 7, 4, 0, 0, 3269, 3270, 7, 23, 0, 0, 3270, 3271, 7, 8, 0, 0, 3271, + 3272, 7, 18, 0, 0, 3272, 3273, 7, 19, 0, 0, 3273, 3274, 7, 18, 0, 0, 3274, + 750, 1, 0, 0, 0, 3275, 3276, 7, 0, 0, 0, 3276, 3277, 7, 13, 0, 0, 3277, + 3278, 7, 24, 0, 0, 3278, 752, 1, 0, 0, 0, 3279, 3280, 7, 18, 0, 0, 3280, + 3281, 7, 14, 0, 0, 3281, 3282, 7, 12, 0, 0, 3282, 3283, 7, 4, 0, 0, 3283, + 754, 1, 0, 0, 0, 3284, 3285, 7, 11, 0, 0, 3285, 3286, 7, 8, 0, 0, 3286, + 3287, 7, 10, 0, 0, 3287, 3288, 7, 4, 0, 0, 3288, 756, 1, 0, 0, 0, 3289, + 3290, 7, 8, 0, 0, 3290, 3291, 7, 18, 0, 0, 3291, 758, 1, 0, 0, 0, 3292, + 3293, 7, 13, 0, 0, 3293, 3294, 7, 14, 0, 0, 3294, 760, 1, 0, 0, 0, 3295, + 3296, 7, 8, 0, 0, 3296, 3297, 7, 13, 0, 0, 3297, 3298, 7, 19, 0, 0, 3298, + 3299, 7, 14, 0, 0, 3299, 762, 1, 0, 0, 0, 3300, 3301, 7, 0, 0, 0, 3301, + 3302, 7, 18, 0, 0, 3302, 3303, 7, 18, 0, 0, 3303, 3304, 7, 4, 0, 0, 3304, + 3305, 7, 17, 0, 0, 3305, 3306, 7, 19, 0, 0, 3306, 3307, 5, 95, 0, 0, 3307, + 3308, 7, 17, 0, 0, 3308, 3309, 7, 14, 0, 0, 3309, 3310, 7, 22, 0, 0, 3310, + 3311, 7, 18, 0, 0, 3311, 3312, 5, 95, 0, 0, 3312, 3313, 7, 12, 0, 0, 3313, + 3314, 7, 14, 0, 0, 3314, 3315, 7, 3, 0, 0, 3315, 3316, 7, 8, 0, 0, 3316, + 3317, 7, 5, 0, 0, 3317, 3318, 7, 8, 0, 0, 3318, 3319, 7, 4, 0, 0, 3319, + 3320, 7, 3, 0, 0, 3320, 764, 1, 0, 0, 0, 3321, 3322, 7, 2, 0, 0, 3322, + 3323, 7, 14, 0, 0, 3323, 3324, 7, 13, 0, 0, 3324, 3325, 7, 5, 0, 0, 3325, + 3326, 7, 11, 0, 0, 3326, 3327, 7, 8, 0, 0, 3327, 3328, 7, 2, 0, 0, 3328, + 3329, 7, 19, 0, 0, 3329, 766, 1, 0, 0, 0, 3330, 3331, 7, 13, 0, 0, 3331, + 3332, 7, 14, 0, 0, 3332, 3333, 7, 19, 0, 0, 3333, 3334, 7, 7, 0, 0, 3334, + 3335, 7, 8, 0, 0, 3335, 3336, 7, 13, 0, 0, 3336, 3337, 7, 6, 0, 0, 3337, + 768, 1, 0, 0, 0, 3338, 3339, 7, 12, 0, 0, 3339, 3340, 7, 4, 0, 0, 3340, + 3341, 7, 17, 0, 0, 3341, 3342, 7, 6, 0, 0, 3342, 3343, 7, 4, 0, 0, 3343, + 770, 1, 0, 0, 0, 3344, 3345, 7, 2, 0, 0, 3345, 3346, 7, 17, 0, 0, 3346, + 3347, 7, 4, 0, 0, 3347, 3348, 7, 0, 0, 0, 3348, 3349, 7, 19, 0, 0, 3349, + 3350, 7, 4, 0, 0, 3350, 772, 1, 0, 0, 0, 3351, 3352, 7, 4, 0, 0, 3352, + 3353, 7, 13, 0, 0, 3353, 3354, 7, 20, 0, 0, 3354, 3355, 7, 12, 0, 0, 3355, + 774, 1, 0, 0, 0, 3356, 3357, 7, 3, 0, 0, 3357, 3358, 7, 4, 0, 0, 3358, + 3359, 7, 18, 0, 0, 3359, 3360, 7, 19, 0, 0, 3360, 3361, 7, 8, 0, 0, 3361, + 3362, 7, 13, 0, 0, 3362, 3363, 7, 0, 0, 0, 3363, 3364, 7, 19, 0, 0, 3364, + 3365, 7, 8, 0, 0, 3365, 3366, 7, 14, 0, 0, 3366, 3367, 7, 13, 0, 0, 3367, + 776, 1, 0, 0, 0, 3368, 3369, 7, 15, 0, 0, 3369, 3370, 7, 17, 0, 0, 3370, + 3371, 7, 14, 0, 0, 3371, 3372, 7, 15, 0, 0, 3372, 3373, 7, 4, 0, 0, 3373, + 3374, 7, 17, 0, 0, 3374, 3375, 7, 19, 0, 0, 3375, 3376, 7, 24, 0, 0, 3376, + 778, 1, 0, 0, 0, 3377, 3378, 7, 6, 0, 0, 3378, 3379, 7, 17, 0, 0, 3379, + 3380, 7, 0, 0, 0, 3380, 3381, 7, 15, 0, 0, 3381, 3382, 7, 7, 0, 0, 3382, + 780, 1, 0, 0, 0, 3383, 3384, 7, 13, 0, 0, 3384, 3385, 7, 14, 0, 0, 3385, + 3386, 7, 3, 0, 0, 3386, 3387, 7, 4, 0, 0, 3387, 782, 1, 0, 0, 0, 3388, + 3389, 7, 15, 0, 0, 3389, 3390, 7, 17, 0, 0, 3390, 3391, 7, 14, 0, 0, 3391, + 3392, 7, 15, 0, 0, 3392, 3393, 7, 4, 0, 0, 3393, 3394, 7, 17, 0, 0, 3394, + 3395, 7, 19, 0, 0, 3395, 3396, 7, 8, 0, 0, 3396, 3397, 7, 4, 0, 0, 3397, + 3398, 7, 18, 0, 0, 3398, 784, 1, 0, 0, 0, 3399, 3400, 7, 11, 0, 0, 3400, + 3401, 7, 0, 0, 0, 3401, 3402, 7, 1, 0, 0, 3402, 3403, 7, 4, 0, 0, 3403, + 3404, 7, 11, 0, 0, 3404, 786, 1, 0, 0, 0, 3405, 3406, 7, 4, 0, 0, 3406, + 3407, 7, 3, 0, 0, 3407, 3408, 7, 6, 0, 0, 3408, 3409, 7, 4, 0, 0, 3409, + 788, 1, 0, 0, 0, 3410, 3411, 7, 13, 0, 0, 3411, 3412, 7, 4, 0, 0, 3412, + 3413, 7, 23, 0, 0, 3413, 3414, 7, 19, 0, 0, 3414, 790, 1, 0, 0, 0, 3415, + 3416, 7, 0, 0, 0, 3416, 3417, 7, 18, 0, 0, 3417, 3418, 7, 2, 0, 0, 3418, + 3419, 7, 4, 0, 0, 3419, 3420, 7, 13, 0, 0, 3420, 3421, 7, 3, 0, 0, 3421, + 3422, 7, 8, 0, 0, 3422, 3423, 7, 13, 0, 0, 3423, 3424, 7, 6, 0, 0, 3424, + 792, 1, 0, 0, 0, 3425, 3426, 7, 3, 0, 0, 3426, 3427, 7, 4, 0, 0, 3427, + 3428, 7, 18, 0, 0, 3428, 3429, 7, 2, 0, 0, 3429, 3430, 7, 4, 0, 0, 3430, + 3431, 7, 13, 0, 0, 3431, 3432, 7, 3, 0, 0, 3432, 3433, 7, 8, 0, 0, 3433, + 3434, 7, 13, 0, 0, 3434, 3435, 7, 6, 0, 0, 3435, 794, 1, 0, 0, 0, 3436, + 3437, 7, 18, 0, 0, 3437, 3438, 7, 10, 0, 0, 3438, 3439, 7, 8, 0, 0, 3439, + 3440, 7, 15, 0, 0, 3440, 796, 1, 0, 0, 0, 3441, 3442, 7, 18, 0, 0, 3442, + 3443, 7, 7, 0, 0, 3443, 3444, 7, 14, 0, 0, 3444, 3445, 7, 17, 0, 0, 3445, + 3446, 7, 19, 0, 0, 3446, 3447, 7, 4, 0, 0, 3447, 3448, 7, 18, 0, 0, 3448, + 3449, 7, 19, 0, 0, 3449, 798, 1, 0, 0, 0, 3450, 3451, 7, 15, 0, 0, 3451, + 3452, 7, 0, 0, 0, 3452, 3453, 7, 19, 0, 0, 3453, 3454, 7, 7, 0, 0, 3454, + 800, 1, 0, 0, 0, 3455, 3456, 7, 15, 0, 0, 3456, 3457, 7, 0, 0, 0, 3457, + 3458, 7, 19, 0, 0, 3458, 3459, 7, 7, 0, 0, 3459, 3460, 7, 18, 0, 0, 3460, + 802, 1, 0, 0, 0, 3461, 3462, 7, 22, 0, 0, 3462, 3463, 7, 0, 0, 0, 3463, + 3464, 7, 11, 0, 0, 3464, 3465, 7, 10, 0, 0, 3465, 804, 1, 0, 0, 0, 3466, + 3467, 7, 19, 0, 0, 3467, 3468, 7, 17, 0, 0, 3468, 3469, 7, 0, 0, 0, 3469, + 3470, 7, 8, 0, 0, 3470, 3471, 7, 11, 0, 0, 3471, 806, 1, 0, 0, 0, 3472, + 3473, 7, 0, 0, 0, 3473, 3474, 7, 2, 0, 0, 3474, 3475, 7, 24, 0, 0, 3475, + 3476, 7, 2, 0, 0, 3476, 3477, 7, 11, 0, 0, 3477, 3478, 7, 8, 0, 0, 3478, + 3479, 7, 2, 0, 0, 3479, 808, 1, 0, 0, 0, 3480, 3481, 7, 14, 0, 0, 3481, + 3482, 7, 15, 0, 0, 3482, 3483, 7, 19, 0, 0, 3483, 3484, 7, 8, 0, 0, 3484, + 3485, 7, 14, 0, 0, 3485, 3486, 7, 13, 0, 0, 3486, 3487, 7, 0, 0, 0, 3487, + 3488, 7, 11, 0, 0, 3488, 810, 1, 0, 0, 0, 3489, 3490, 7, 11, 0, 0, 3490, + 3491, 7, 4, 0, 0, 3491, 3492, 7, 19, 0, 0, 3492, 812, 1, 0, 0, 0, 3493, + 3495, 3, 9, 4, 0, 3494, 3496, 7, 30, 0, 0, 3495, 3494, 1, 0, 0, 0, 3496, + 3497, 1, 0, 0, 0, 3497, 3495, 1, 0, 0, 0, 3497, 3498, 1, 0, 0, 0, 3498, + 814, 1, 0, 0, 0, 3499, 3503, 7, 32, 0, 0, 3500, 3502, 7, 33, 0, 0, 3501, + 3500, 1, 0, 0, 0, 3502, 3505, 1, 0, 0, 0, 3503, 3501, 1, 0, 0, 0, 3503, + 3504, 1, 0, 0, 0, 3504, 816, 1, 0, 0, 0, 3505, 3503, 1, 0, 0, 0, 3506, + 3511, 3, 115, 57, 0, 3507, 3510, 8, 34, 0, 0, 3508, 3510, 3, 139, 69, 0, + 3509, 3507, 1, 0, 0, 0, 3509, 3508, 1, 0, 0, 0, 3510, 3513, 1, 0, 0, 0, + 3511, 3509, 1, 0, 0, 0, 3511, 3512, 1, 0, 0, 0, 3512, 818, 1, 0, 0, 0, + 3513, 3511, 1, 0, 0, 0, 3514, 3515, 3, 817, 408, 0, 3515, 3516, 3, 115, + 57, 0, 3516, 820, 1, 0, 0, 0, 3517, 3520, 3, 815, 407, 0, 3518, 3520, 3, + 819, 409, 0, 3519, 3517, 1, 0, 0, 0, 3519, 3518, 1, 0, 0, 0, 3520, 822, + 1, 0, 0, 0, 3521, 3522, 3, 817, 408, 0, 3522, 824, 1, 0, 0, 0, 3523, 3524, + 7, 35, 0, 0, 3524, 3525, 1, 0, 0, 0, 3525, 3526, 6, 412, 0, 0, 3526, 826, + 1, 0, 0, 0, 3527, 3528, 5, 47, 0, 0, 3528, 3529, 5, 42, 0, 0, 3529, 3530, + 5, 42, 0, 0, 3530, 3544, 5, 47, 0, 0, 3531, 3532, 5, 47, 0, 0, 3532, 3533, + 5, 42, 0, 0, 3533, 3534, 1, 0, 0, 0, 3534, 3538, 8, 36, 0, 0, 3535, 3537, + 9, 0, 0, 0, 3536, 3535, 1, 0, 0, 0, 3537, 3540, 1, 0, 0, 0, 3538, 3539, + 1, 0, 0, 0, 3538, 3536, 1, 0, 0, 0, 3539, 3541, 1, 0, 0, 0, 3540, 3538, + 1, 0, 0, 0, 3541, 3542, 5, 42, 0, 0, 3542, 3544, 5, 47, 0, 0, 3543, 3527, + 1, 0, 0, 0, 3543, 3531, 1, 0, 0, 0, 3544, 828, 1, 0, 0, 0, 3545, 3546, + 5, 45, 0, 0, 3546, 3547, 5, 45, 0, 0, 3547, 3551, 1, 0, 0, 0, 3548, 3550, + 8, 37, 0, 0, 3549, 3548, 1, 0, 0, 0, 3550, 3553, 1, 0, 0, 0, 3551, 3549, + 1, 0, 0, 0, 3551, 3552, 1, 0, 0, 0, 3552, 3557, 1, 0, 0, 0, 3553, 3551, + 1, 0, 0, 0, 3554, 3558, 7, 37, 0, 0, 3555, 3556, 5, 13, 0, 0, 3556, 3558, + 5, 10, 0, 0, 3557, 3554, 1, 0, 0, 0, 3557, 3555, 1, 0, 0, 0, 3557, 3558, + 1, 0, 0, 0, 3558, 830, 1, 0, 0, 0, 3559, 3563, 5, 35, 0, 0, 3560, 3562, + 8, 37, 0, 0, 3561, 3560, 1, 0, 0, 0, 3562, 3565, 1, 0, 0, 0, 3563, 3561, + 1, 0, 0, 0, 3563, 3564, 1, 0, 0, 0, 3564, 3569, 1, 0, 0, 0, 3565, 3563, + 1, 0, 0, 0, 3566, 3570, 7, 37, 0, 0, 3567, 3568, 5, 13, 0, 0, 3568, 3570, + 5, 10, 0, 0, 3569, 3566, 1, 0, 0, 0, 3569, 3567, 1, 0, 0, 0, 3569, 3570, + 1, 0, 0, 0, 3570, 832, 1, 0, 0, 0, 3571, 3575, 3, 827, 413, 0, 3572, 3575, + 3, 829, 414, 0, 3573, 3575, 3, 831, 415, 0, 3574, 3571, 1, 0, 0, 0, 3574, + 3572, 1, 0, 0, 0, 3574, 3573, 1, 0, 0, 0, 3575, 3576, 1, 0, 0, 0, 3576, + 3577, 6, 416, 0, 0, 3577, 834, 1, 0, 0, 0, 53, 0, 999, 1012, 1014, 1023, + 1025, 1034, 1036, 1040, 1044, 1053, 1055, 1059, 1063, 1070, 1076, 1085, + 1091, 1095, 1099, 1104, 1109, 1114, 1119, 1127, 1131, 1139, 1143, 1147, + 1152, 1157, 1160, 1164, 1167, 1174, 1177, 1183, 1187, 1191, 1200, 1208, + 3497, 3503, 3509, 3511, 3519, 3538, 3543, 3551, 3557, 3563, 3569, 3574, + 1, 0, 1, 0, + } + deserializer := antlr.NewATNDeserializer(nil) + staticData.atn = deserializer.Deserialize(staticData.serializedATN) + atn := staticData.atn + staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState)) + decisionToDFA := staticData.decisionToDFA + for index, state := range atn.DecisionToState { + decisionToDFA[index] = antlr.NewDFA(state, index) + } +} + +// GoogleSQLLexerInit initializes any static state used to implement GoogleSQLLexer. By default the +// static state used to implement the lexer is lazily initialized during the first call to +// NewGoogleSQLLexer(). You can call this function if you wish to initialize the static state ahead +// of time. +func GoogleSQLLexerInit() { + staticData := &GoogleSQLLexerLexerStaticData + staticData.once.Do(googlesqllexerLexerInit) +} + +// NewGoogleSQLLexer produces a new lexer instance for the optional input antlr.CharStream. +func NewGoogleSQLLexer(input antlr.CharStream) *GoogleSQLLexer { + GoogleSQLLexerInit() + l := new(GoogleSQLLexer) + l.BaseLexer = antlr.NewBaseLexer(input) + staticData := &GoogleSQLLexerLexerStaticData + 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 = "GoogleSQLLexer.g4" + // TODO: l.EOF = antlr.TokenEOF + + return l +} + +// GoogleSQLLexer tokens. +const ( + GoogleSQLLexerEQUAL_OPERATOR = 1 + GoogleSQLLexerNOT_EQUAL_OPERATOR = 2 + GoogleSQLLexerNOT_EQUAL2_OPERATOR = 3 + GoogleSQLLexerLT_OPERATOR = 4 + GoogleSQLLexerLE_OPERATOR = 5 + GoogleSQLLexerGT_OPERATOR = 6 + GoogleSQLLexerGE_OPERATOR = 7 + GoogleSQLLexerKL_OPERATOR = 8 + GoogleSQLLexerKR_OPERATOR = 9 + GoogleSQLLexerPLUS_OPERATOR = 10 + GoogleSQLLexerMINUS_OPERATOR = 11 + GoogleSQLLexerMULTIPLY_OPERATOR = 12 + GoogleSQLLexerDIVIDE_OPERATOR = 13 + GoogleSQLLexerBITWISE_NOT_OPERATOR = 14 + GoogleSQLLexerEXCLAMATION_OPERATOR = 15 + GoogleSQLLexerMODULO_OPERATOR = 16 + GoogleSQLLexerCOMMA_SYMBOL = 17 + GoogleSQLLexerDOT_SYMBOL = 18 + GoogleSQLLexerLC_BRACKET_SYMBOL = 19 + GoogleSQLLexerRC_BRACKET_SYMBOL = 20 + GoogleSQLLexerLR_BRACKET_SYMBOL = 21 + GoogleSQLLexerRR_BRACKET_SYMBOL = 22 + GoogleSQLLexerLS_BRACKET_SYMBOL = 23 + GoogleSQLLexerRS_BRACKET_SYMBOL = 24 + GoogleSQLLexerSTROKE_SYMBOL = 25 + GoogleSQLLexerCOLON_SYMBOL = 26 + GoogleSQLLexerSEMI_SYMBOL = 27 + GoogleSQLLexerSINGLE_QUOTE_SYMBOL = 28 + GoogleSQLLexerSINGLE_QUOTE_3_SYMBOL = 29 + GoogleSQLLexerDOUBLE_QUOTE_SYMBOL = 30 + GoogleSQLLexerDOUBLE_QUOTE_3_SYMBOL = 31 + GoogleSQLLexerBACKQUOTE_SYMBOL = 32 + GoogleSQLLexerQUESTION_SYMBOL = 33 + GoogleSQLLexerAT_SYMBOL = 34 + GoogleSQLLexerATAT_SYMBOL = 35 + GoogleSQLLexerEQUAL_GT_BRACKET_SYMBOL = 36 + GoogleSQLLexerSUB_GT_BRACKET_SYMBOL = 37 + GoogleSQLLexerPLUS_EQUAL_SYMBOL = 38 + GoogleSQLLexerSUB_EQUAL_SYMBOL = 39 + GoogleSQLLexerPIPE_SYMBOL = 40 + GoogleSQLLexerCIRCUMFLEX_SYMBOL = 41 + GoogleSQLLexerBIT_AND_SYMBOL = 42 + GoogleSQLLexerBOOL_OR_SYMBOL = 43 + GoogleSQLLexerSTRING_LITERAL = 44 + GoogleSQLLexerBYTES_LITERAL = 45 + GoogleSQLLexerUNCLOSED_STRING_LITERAL = 46 + GoogleSQLLexerUNCLOSED_TRIPLE_QUOTED_STRING_LITERAL = 47 + GoogleSQLLexerUNCLOSED_RAW_STRING_LITERAL = 48 + GoogleSQLLexerUNCLOSED_TRIPLE_QUOTED_RAW_STRING_LITERAL = 49 + GoogleSQLLexerUNCLOSED_BYTES_LITERAL = 50 + GoogleSQLLexerUNCLOSED_TRIPLE_QUOTED_BYTES_LITERAL = 51 + GoogleSQLLexerUNCLOSED_RAW_BYTES_LITERAL = 52 + GoogleSQLLexerUNCLOSED_TRIPLE_QUOTED_RAW_BYTES_LITERAL = 53 + GoogleSQLLexerFLOATING_POINT_LITERAL = 54 + GoogleSQLLexerINTEGER_LITERAL = 55 + GoogleSQLLexerARRAY_SYMBOL = 56 + GoogleSQLLexerALL_SYMBOL = 57 + GoogleSQLLexerAS_SYMBOL = 58 + GoogleSQLLexerASC_SYMBOL = 59 + GoogleSQLLexerBY_SYMBOL = 60 + GoogleSQLLexerCROSS_SYMBOL = 61 + GoogleSQLLexerJOIN_SYMBOL = 62 + GoogleSQLLexerDELTA_SYMBOL = 63 + GoogleSQLLexerDESC_SYMBOL = 64 + GoogleSQLLexerDIFFERENTIAL_PRIVACY_SYMBOL = 65 + GoogleSQLLexerDISTINCT_SYMBOL = 66 + GoogleSQLLexerEPSILON_SYMBOL = 67 + GoogleSQLLexerEXCEPT_SYMBOL = 68 + GoogleSQLLexerEXCLUDE_SYMBOL = 69 + GoogleSQLLexerFOR_SYMBOL = 70 + GoogleSQLLexerFROM_SYMBOL = 71 + GoogleSQLLexerFULL_SYMBOL = 72 + GoogleSQLLexerIN_SYMBOL = 73 + GoogleSQLLexerINCLUDE_SYMBOL = 74 + GoogleSQLLexerINNER_SYMBOL = 75 + GoogleSQLLexerINTERSECT_SYMBOL = 76 + GoogleSQLLexerLEFT_SYMBOL = 77 + GoogleSQLLexerLIMIT_SYMBOL = 78 + GoogleSQLLexerMAX_GROUPS_CONTRIBUTED_SYMBOL = 79 + GoogleSQLLexerNULL_SYMBOL = 80 + GoogleSQLLexerNULLS_SYMBOL = 81 + GoogleSQLLexerOF_SYMBOL = 82 + GoogleSQLLexerOFFSET_SYMBOL = 83 + GoogleSQLLexerON_SYMBOL = 84 + GoogleSQLLexerOPTIONS_SYMBOL = 85 + GoogleSQLLexerORDER_SYMBOL = 86 + GoogleSQLLexerOUTER_SYMBOL = 87 + GoogleSQLLexerPERCENT_SYMBOL = 88 + GoogleSQLLexerPIVOT_SYMBOL = 89 + GoogleSQLLexerPRIVACY_UNIT_COLUMN_SYMBOL = 90 + GoogleSQLLexerRIGHT_SYMBOL = 91 + GoogleSQLLexerRECURSIVE_SYMBOL = 92 + GoogleSQLLexerREPLACE_SYMBOL = 93 + GoogleSQLLexerUNPIVOT_SYMBOL = 94 + GoogleSQLLexerSELECT_SYMBOL = 95 + GoogleSQLLexerSTRUCT_SYMBOL = 96 + GoogleSQLLexerSYSTEM_SYMBOL = 97 + GoogleSQLLexerSYSTEM_TIME_SYMBOL = 98 + GoogleSQLLexerTABLESAMPLE_SYMBOL = 99 + GoogleSQLLexerUNION_SYMBOL = 100 + GoogleSQLLexerUNNEST_SYMBOL = 101 + GoogleSQLLexerUSING_SYMBOL = 102 + GoogleSQLLexerVALUE_SYMBOL = 103 + GoogleSQLLexerWITH_SYMBOL = 104 + GoogleSQLLexerTRUE_SYMBOL = 105 + GoogleSQLLexerFALSE_SYMBOL = 106 + GoogleSQLLexerNUMERIC_SYMBOL = 107 + GoogleSQLLexerDECIMAL_SYMBOL = 108 + GoogleSQLLexerBIGNUMERIC_SYMBOL = 109 + GoogleSQLLexerBIGDECIMAL_SYMBOL = 110 + GoogleSQLLexerNOT_SYMBOL = 111 + GoogleSQLLexerAND_SYMBOL = 112 + GoogleSQLLexerOR_SYMBOL = 113 + GoogleSQLLexerJSON_SYMBOL = 114 + GoogleSQLLexerDATE_SYMBOL = 115 + GoogleSQLLexerTIME_SYMBOL = 116 + GoogleSQLLexerDATETIME_SYMBOL = 117 + GoogleSQLLexerTIMESTAMP_SYMBOL = 118 + GoogleSQLLexerRANGE_SYMBOL = 119 + GoogleSQLLexerINTERVAL_SYMBOL = 120 + GoogleSQLLexerSIMPLE_SYMBOL = 121 + GoogleSQLLexerABORT_SYMBOL = 122 + GoogleSQLLexerACCESS_SYMBOL = 123 + GoogleSQLLexerACTION_SYMBOL = 124 + GoogleSQLLexerAGGREGATE_SYMBOL = 125 + GoogleSQLLexerADD_SYMBOL = 126 + GoogleSQLLexerALTER_SYMBOL = 127 + GoogleSQLLexerALWAYS_SYMBOL = 128 + GoogleSQLLexerANALYZE_SYMBOL = 129 + GoogleSQLLexerAPPROX_SYMBOL = 130 + GoogleSQLLexerARE_SYMBOL = 131 + GoogleSQLLexerASSERT_SYMBOL = 132 + GoogleSQLLexerBATCH_SYMBOL = 133 + GoogleSQLLexerBEGIN_SYMBOL = 134 + GoogleSQLLexerBREAK_SYMBOL = 135 + GoogleSQLLexerCALL_SYMBOL = 136 + GoogleSQLLexerCASCADE_SYMBOL = 137 + GoogleSQLLexerCHECK_SYMBOL = 138 + GoogleSQLLexerCLAMPED_SYMBOL = 139 + GoogleSQLLexerCLONE_SYMBOL = 140 + GoogleSQLLexerCOPY_SYMBOL = 141 + GoogleSQLLexerCLUSTER_SYMBOL = 142 + GoogleSQLLexerCOLUMN_SYMBOL = 143 + GoogleSQLLexerCOLUMNS_SYMBOL = 144 + GoogleSQLLexerCOMMIT_SYMBOL = 145 + GoogleSQLLexerCONNECTION_SYMBOL = 146 + GoogleSQLLexerCONSTANT_SYMBOL = 147 + GoogleSQLLexerCONSTRAINT_SYMBOL = 148 + GoogleSQLLexerCONTINUE_SYMBOL = 149 + GoogleSQLLexerCORRESPONDING_SYMBOL = 150 + GoogleSQLLexerCYCLE_SYMBOL = 151 + GoogleSQLLexerDATA_SYMBOL = 152 + GoogleSQLLexerDATABASE_SYMBOL = 153 + GoogleSQLLexerDECLARE_SYMBOL = 154 + GoogleSQLLexerDEFINER_SYMBOL = 155 + GoogleSQLLexerDELETE_SYMBOL = 156 + GoogleSQLLexerDELETION_SYMBOL = 157 + GoogleSQLLexerDEPTH_SYMBOL = 158 + GoogleSQLLexerDESCRIBE_SYMBOL = 159 + GoogleSQLLexerDETERMINISTIC_SYMBOL = 160 + GoogleSQLLexerDO_SYMBOL = 161 + GoogleSQLLexerDROP_SYMBOL = 162 + GoogleSQLLexerELSEIF_SYMBOL = 163 + GoogleSQLLexerENFORCED_SYMBOL = 164 + GoogleSQLLexerERROR_SYMBOL = 165 + GoogleSQLLexerEXCEPTION_SYMBOL = 166 + GoogleSQLLexerEXECUTE_SYMBOL = 167 + GoogleSQLLexerEXPLAIN_SYMBOL = 168 + GoogleSQLLexerEXPORT_SYMBOL = 169 + GoogleSQLLexerEXTEND_SYMBOL = 170 + GoogleSQLLexerEXTERNAL_SYMBOL = 171 + GoogleSQLLexerFILES_SYMBOL = 172 + GoogleSQLLexerFILTER_SYMBOL = 173 + GoogleSQLLexerFILL_SYMBOL = 174 + GoogleSQLLexerFIRST_SYMBOL = 175 + GoogleSQLLexerFOREIGN_SYMBOL = 176 + GoogleSQLLexerFORMAT_SYMBOL = 177 + GoogleSQLLexerFUNCTION_SYMBOL = 178 + GoogleSQLLexerGENERATED_SYMBOL = 179 + GoogleSQLLexerGRANT_SYMBOL = 180 + GoogleSQLLexerGROUP_ROWS_SYMBOL = 181 + GoogleSQLLexerHIDDEN_SYMBOL = 182 + GoogleSQLLexerIDENTITY_SYMBOL = 183 + GoogleSQLLexerIMMEDIATE_SYMBOL = 184 + GoogleSQLLexerIMMUTABLE_SYMBOL = 185 + GoogleSQLLexerIMPORT_SYMBOL = 186 + GoogleSQLLexerINCREMENT_SYMBOL = 187 + GoogleSQLLexerINDEX_SYMBOL = 188 + GoogleSQLLexerINOUT_SYMBOL = 189 + GoogleSQLLexerINPUT_SYMBOL = 190 + GoogleSQLLexerINSERT_SYMBOL = 191 + GoogleSQLLexerINVOKER_SYMBOL = 192 + GoogleSQLLexerISOLATION_SYMBOL = 193 + GoogleSQLLexerITERATE_SYMBOL = 194 + GoogleSQLLexerKEY_SYMBOL = 195 + GoogleSQLLexerLANGUAGE_SYMBOL = 196 + GoogleSQLLexerLAST_SYMBOL = 197 + GoogleSQLLexerLEAVE_SYMBOL = 198 + GoogleSQLLexerLEVEL_SYMBOL = 199 + GoogleSQLLexerLOAD_SYMBOL = 200 + GoogleSQLLexerLOOP_SYMBOL = 201 + GoogleSQLLexerMACRO_SYMBOL = 202 + GoogleSQLLexerMAP_SYMBOL = 203 + GoogleSQLLexerMATCH_SYMBOL = 204 + GoogleSQLLexerKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL = 205 + GoogleSQLLexerMATCHED_SYMBOL = 206 + GoogleSQLLexerMATERIALIZED_SYMBOL = 207 + GoogleSQLLexerMAX_SYMBOL = 208 + GoogleSQLLexerMAXVALUE_SYMBOL = 209 + GoogleSQLLexerMEASURES_SYMBOL = 210 + GoogleSQLLexerMESSAGE_SYMBOL = 211 + GoogleSQLLexerMETADATA_SYMBOL = 212 + GoogleSQLLexerMIN_SYMBOL = 213 + GoogleSQLLexerMINVALUE_SYMBOL = 214 + GoogleSQLLexerMODEL_SYMBOL = 215 + GoogleSQLLexerMODULE_SYMBOL = 216 + GoogleSQLLexerONLY_SYMBOL = 217 + GoogleSQLLexerOUT_SYMBOL = 218 + GoogleSQLLexerOUTPUT_SYMBOL = 219 + GoogleSQLLexerOVERWRITE_SYMBOL = 220 + GoogleSQLLexerPARTITIONS_SYMBOL = 221 + GoogleSQLLexerPATTERN_SYMBOL = 222 + GoogleSQLLexerPOLICIES_SYMBOL = 223 + GoogleSQLLexerPOLICY_SYMBOL = 224 + GoogleSQLLexerPRIMARY_SYMBOL = 225 + GoogleSQLLexerPRIVATE_SYMBOL = 226 + GoogleSQLLexerPRIVILEGE_SYMBOL = 227 + GoogleSQLLexerPRIVILEGES_SYMBOL = 228 + GoogleSQLLexerPROCEDURE_SYMBOL = 229 + GoogleSQLLexerPROJECT_SYMBOL = 230 + GoogleSQLLexerPUBLIC_SYMBOL = 231 + GoogleSQLLexerRAISE_SYMBOL = 232 + GoogleSQLLexerREAD_SYMBOL = 233 + GoogleSQLLexerREFERENCES_SYMBOL = 234 + GoogleSQLLexerREMOTE_SYMBOL = 235 + GoogleSQLLexerREMOVE_SYMBOL = 236 + GoogleSQLLexerRENAME_SYMBOL = 237 + GoogleSQLLexerREPEAT_SYMBOL = 238 + GoogleSQLLexerREPEATABLE_SYMBOL = 239 + GoogleSQLLexerREPLACE_FIELDS_SYMBOL = 240 + GoogleSQLLexerREPLICA_SYMBOL = 241 + GoogleSQLLexerREPORT_SYMBOL = 242 + GoogleSQLLexerRESTRICT_SYMBOL = 243 + GoogleSQLLexerRESTRICTION_SYMBOL = 244 + GoogleSQLLexerRETURNS_SYMBOL = 245 + GoogleSQLLexerRETURN_SYMBOL = 246 + GoogleSQLLexerREVOKE_SYMBOL = 247 + GoogleSQLLexerROLLBACK_SYMBOL = 248 + GoogleSQLLexerROW_SYMBOL = 249 + GoogleSQLLexerRUN_SYMBOL = 250 + GoogleSQLLexerSAFE_CAST_SYMBOL = 251 + GoogleSQLLexerSCHEMA_SYMBOL = 252 + GoogleSQLLexerSEARCH_SYMBOL = 253 + GoogleSQLLexerSECURITY_SYMBOL = 254 + GoogleSQLLexerSEQUENCE_SYMBOL = 255 + GoogleSQLLexerSETS_SYMBOL = 256 + GoogleSQLLexerSET_SYMBOL = 257 + GoogleSQLLexerSHOW_SYMBOL = 258 + GoogleSQLLexerSNAPSHOT_SYMBOL = 259 + GoogleSQLLexerSOURCE_SYMBOL = 260 + GoogleSQLLexerSQL_SYMBOL = 261 + GoogleSQLLexerSTABLE_SYMBOL = 262 + GoogleSQLLexerSTART_SYMBOL = 263 + GoogleSQLLexerSTATIC_DESCRIBE_SYMBOL = 264 + GoogleSQLLexerSTORED_SYMBOL = 265 + GoogleSQLLexerSTORING_SYMBOL = 266 + GoogleSQLLexerSTRICT_SYMBOL = 267 + GoogleSQLLexerTABLE_SYMBOL = 268 + GoogleSQLLexerTABLES_SYMBOL = 269 + GoogleSQLLexerTARGET_SYMBOL = 270 + GoogleSQLLexerTEMP_SYMBOL = 271 + GoogleSQLLexerTEMPORARY_SYMBOL = 272 + GoogleSQLLexerTRANSACTION_SYMBOL = 273 + GoogleSQLLexerTRANSFORM_SYMBOL = 274 + GoogleSQLLexerTRUNCATE_SYMBOL = 275 + GoogleSQLLexerTYPE_SYMBOL = 276 + GoogleSQLLexerUNDROP_SYMBOL = 277 + GoogleSQLLexerUNIQUE_SYMBOL = 278 + GoogleSQLLexerUNKNOWN_SYMBOL = 279 + GoogleSQLLexerUNTIL_SYMBOL = 280 + GoogleSQLLexerUPDATE_SYMBOL = 281 + GoogleSQLLexerVALUES_SYMBOL = 282 + GoogleSQLLexerVECTOR_SYMBOL = 283 + GoogleSQLLexerVIEW_SYMBOL = 284 + GoogleSQLLexerVIEWS_SYMBOL = 285 + GoogleSQLLexerVOLATILE_SYMBOL = 286 + GoogleSQLLexerWEIGHT_SYMBOL = 287 + GoogleSQLLexerWHILE_SYMBOL = 288 + GoogleSQLLexerWRITE_SYMBOL = 289 + GoogleSQLLexerZONE_SYMBOL = 290 + GoogleSQLLexerDESCRIPTOR_SYMBOL = 291 + GoogleSQLLexerINTERLEAVE_SYMBOL = 292 + GoogleSQLLexerNULL_FILTERED_SYMBOL = 293 + GoogleSQLLexerPARENT_SYMBOL = 294 + GoogleSQLLexerNEW_SYMBOL = 295 + GoogleSQLLexerEND_SYMBOL = 296 + GoogleSQLLexerCASE_SYMBOL = 297 + GoogleSQLLexerWHEN_SYMBOL = 298 + GoogleSQLLexerTHEN_SYMBOL = 299 + GoogleSQLLexerELSE_SYMBOL = 300 + GoogleSQLLexerCAST_SYMBOL = 301 + GoogleSQLLexerEXTRACT_SYMBOL = 302 + GoogleSQLLexerCOLLATE_SYMBOL = 303 + GoogleSQLLexerIF_SYMBOL = 304 + GoogleSQLLexerGROUPING_SYMBOL = 305 + GoogleSQLLexerHAVING_SYMBOL = 306 + GoogleSQLLexerGROUP_SYMBOL = 307 + GoogleSQLLexerROLLUP_SYMBOL = 308 + GoogleSQLLexerCUBE_SYMBOL = 309 + GoogleSQLLexerHASH_SYMBOL = 310 + GoogleSQLLexerPROTO_SYMBOL = 311 + GoogleSQLLexerPARTITION_SYMBOL = 312 + GoogleSQLLexerIGNORE_SYMBOL = 313 + GoogleSQLLexerRESPECT_SYMBOL = 314 + GoogleSQLLexerROWS_SYMBOL = 315 + GoogleSQLLexerOVER_SYMBOL = 316 + GoogleSQLLexerBETWEEN_SYMBOL = 317 + GoogleSQLLexerUNBOUNDED_SYMBOL = 318 + GoogleSQLLexerCURRENT_SYMBOL = 319 + GoogleSQLLexerPRECEDING_SYMBOL = 320 + GoogleSQLLexerFOLLOWING_SYMBOL = 321 + GoogleSQLLexerNATURAL_SYMBOL = 322 + GoogleSQLLexerQUALIFY_SYMBOL = 323 + GoogleSQLLexerDEFAULT_SYMBOL = 324 + GoogleSQLLexerSLASH_SYMBOL = 325 + GoogleSQLLexerMATCH_RECOGNIZE_SYMBOL = 326 + GoogleSQLLexerDEFINE_SYMBOL = 327 + GoogleSQLLexerLOOKUP_SYMBOL = 328 + GoogleSQLLexerWHERE_SYMBOL = 329 + GoogleSQLLexerWINDOW_SYMBOL = 330 + GoogleSQLLexerTO_SYMBOL = 331 + GoogleSQLLexerEXISTS_SYMBOL = 332 + GoogleSQLLexerANY_SYMBOL = 333 + GoogleSQLLexerSOME_SYMBOL = 334 + GoogleSQLLexerLIKE_SYMBOL = 335 + GoogleSQLLexerIS_SYMBOL = 336 + GoogleSQLLexerNO_SYMBOL = 337 + GoogleSQLLexerINTO_SYMBOL = 338 + GoogleSQLLexerASSERT_ROWS_MODIFIED_SYMBOL = 339 + GoogleSQLLexerCONFLICT_SYMBOL = 340 + GoogleSQLLexerNOTHING_SYMBOL = 341 + GoogleSQLLexerMERGE_SYMBOL = 342 + GoogleSQLLexerCREATE_SYMBOL = 343 + GoogleSQLLexerENUM_SYMBOL = 344 + GoogleSQLLexerDESTINATION_SYMBOL = 345 + GoogleSQLLexerPROPERTY_SYMBOL = 346 + GoogleSQLLexerGRAPH_SYMBOL = 347 + GoogleSQLLexerNODE_SYMBOL = 348 + GoogleSQLLexerPROPERTIES_SYMBOL = 349 + GoogleSQLLexerLABEL_SYMBOL = 350 + GoogleSQLLexerEDGE_SYMBOL = 351 + GoogleSQLLexerNEXT_SYMBOL = 352 + GoogleSQLLexerASCENDING_SYMBOL = 353 + GoogleSQLLexerDESCENDING_SYMBOL = 354 + GoogleSQLLexerSKIP_SYMBOL = 355 + GoogleSQLLexerSHORTEST_SYMBOL = 356 + GoogleSQLLexerPATH_SYMBOL = 357 + GoogleSQLLexerPATHS_SYMBOL = 358 + GoogleSQLLexerWALK_SYMBOL = 359 + GoogleSQLLexerTRAIL_SYMBOL = 360 + GoogleSQLLexerACYCLIC_SYMBOL = 361 + GoogleSQLLexerOPTIONAL_SYMBOL = 362 + GoogleSQLLexerLET_SYMBOL = 363 + GoogleSQLLexerIDENTIFIER = 364 + GoogleSQLLexerUNCLOSED_ESCAPED_IDENTIFIER = 365 + GoogleSQLLexerWHITESPACE = 366 + GoogleSQLLexerCOMMENT = 367 +) diff --git a/googlesql/googlesql_parser.go b/googlesql/googlesql_parser.go new file mode 100644 index 0000000..0270510 --- /dev/null +++ b/googlesql/googlesql_parser.go @@ -0,0 +1,128528 @@ +// Code generated from GoogleSQLParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package googlesql // GoogleSQLParser +import ( + "fmt" + "strconv" + "sync" + + "github.com/antlr4-go/antlr/v4" +) + +// Suppress unused import errors +var _ = fmt.Printf +var _ = strconv.Itoa +var _ = sync.Once{} + +type GoogleSQLParser struct { + *antlr.BaseParser +} + +var GoogleSQLParserParserStaticData struct { + once sync.Once + serializedATN []int32 + LiteralNames []string + SymbolicNames []string + RuleNames []string + PredictionContextCache *antlr.PredictionContextCache + atn *antlr.ATN + decisionToDFA []*antlr.DFA +} + +func googlesqlparserParserInit() { + staticData := &GoogleSQLParserParserStaticData + staticData.LiteralNames = []string{ + "", "'='", "'!='", "'<>'", "'<'", "'<='", "'>'", "'>='", "'<<'", "'>>'", + "'+'", "'-'", "'*'", "'/'", "'~'", "'!'", "'%'", "','", "'.'", "'{'", + "'}'", "'('", "')'", "'['", "']'", "'|'", "':'", "';'", "'''", "'''''", + "'\"'", "'\"\"\"'", "'`'", "'?'", "'@'", "'@@'", "'=>'", "'->'", "'+='", + "'-='", "'|>'", "'^'", "'&'", "'||'", "", "", "", "", "", "", "", "", + "", "", "", "", "'ARRAY'", "'ALL'", "'AS'", "'ASC'", "'BY'", "'CROSS'", + "'JOIN'", "'DELTA'", "'DESC'", "'DIFFERENTIAL_PRIVACY'", "'DISTINCT'", + "'EPSILON'", "'EXCEPT'", "'EXCLUDE'", "'FOR'", "'FROM'", "'FULL'", "'IN'", + "'INCLUDE'", "'INNER'", "'INTERSECT'", "'LEFT'", "'LIMIT'", "'MAX_GROUPS_CONTRIBUTED'", + "'NULL'", "'NULLS'", "'OF'", "'OFFSET'", "'ON'", "'OPTIONS'", "'ORDER'", + "'OUTER'", "'PERCENT'", "'PIVOT'", "'PRIVACY_UNIT_COLUMN'", "'RIGHT'", + "'RECURSIVE'", "'REPLACE'", "'UNPIVOT'", "'SELECT'", "'STRUCT'", "'SYSTEM'", + "'SYSTEM_TIME'", "'TABLESAMPLE'", "'UNION'", "'UNNEST'", "'USING'", + "'VALUE'", "'WITH'", "'TRUE'", "'FALSE'", "'NUMERIC'", "'DECIMAL'", + "'BIGNUMERIC'", "'BIGDECIMAL'", "'NOT'", "'AND'", "'OR'", "'JSON'", + "'DATE'", "'TIME'", "'DATETIME'", "'TIMESTAMP'", "'RANGE'", "'INTERVAL'", + "'SIMPLE'", "'ABORT'", "'ACCESS'", "'ACTION'", "'AGGREGATE'", "'ADD'", + "'ALTER'", "'ALWAYS'", "'ANALYZE'", "'APPROX'", "'ARE'", "'ASSERT'", + "'BATCH'", "'BEGIN'", "'BREAK'", "'CALL'", "'CASCADE'", "'CHECK'", "'CLAMPED'", + "'CLONE'", "'COPY'", "'CLUSTER'", "'COLUMN'", "'COLUMNS'", "'COMMIT'", + "'CONNECTION'", "'CONSTANT'", "'CONSTRAINT'", "'CONTINUE'", "'CORRESPONDING'", + "'CYCLE'", "'DATA'", "'DATABASE'", "'DECLARE'", "'DEFINER'", "'DELETE'", + "'DELETION'", "'DEPTH'", "'DESCRIBE'", "'DETERMINISTIC'", "'DO'", "'DROP'", + "'ELSEIF'", "'ENFORCED'", "'ERROR'", "'EXCEPTION'", "'EXECUTE'", "'EXPLAIN'", + "'EXPORT'", "'EXTEND'", "'EXTERNAL'", "'FILES'", "'FILTER'", "'FILL'", + "'FIRST'", "'FOREIGN'", "'FORMAT'", "'FUNCTION'", "'GENERATED'", "'GRANT'", + "'GROUP_ROWS'", "'HIDDEN'", "'IDENTITY'", "'IMMEDIATE'", "'IMMUTABLE'", + "'IMPORT'", "'INCREMENT'", "'INDEX'", "'INOUT'", "'INPUT'", "'INSERT'", + "'INVOKER'", "'ISOLATION'", "'ITERATE'", "'KEY'", "'LANGUAGE'", "'LAST'", + "'LEAVE'", "'LEVEL'", "'LOAD'", "'LOOP'", "'MACRO'", "'MAP'", "'MATCH'", + "'KW_MATCH_RECOGNIZE_NONRESERVED'", "'MATCHED'", "'MATERIALIZED'", "'MAX'", + "'MAXVALUE'", "'MEASURES'", "'MESSAGE'", "'METADATA'", "'MIN'", "'MINVALUE'", + "'MODEL'", "'MODULE'", "'ONLY'", "'OUT'", "'OUTPUT'", "'OVERWRITE'", + "'PARTITIONS'", "'PATTERN'", "'POLICIES'", "'POLICY'", "'PRIMARY'", + "'PRIVATE'", "'PRIVILEGE'", "'PRIVILEGES'", "'PROCEDURE'", "'PROJECT'", + "'PUBLIC'", "'RAISE'", "'READ'", "'REFERENCES'", "'REMOTE'", "'REMOVE'", + "'RENAME'", "'REPEAT'", "'REPEATABLE'", "'REPLACE_FIELDS'", "'REPLICA'", + "'REPORT'", "'RESTRICT'", "'RESTRICTION'", "'RETURNS'", "'RETURN'", + "'REVOKE'", "'ROLLBACK'", "'ROW'", "'RUN'", "'SAFE_CAST'", "'SCHEMA'", + "'SEARCH'", "'SECURITY'", "'SEQUENCE'", "'SETS'", "'SET'", "'SHOW'", + "'SNAPSHOT'", "'SOURCE'", "'SQL'", "'STABLE'", "'START'", "'STATIC_DESCRIBE'", + "'STORED'", "'STORING'", "'STRICT'", "'TABLE'", "'TABLES'", "'TARGET'", + "'TEMP'", "'TEMPORARY'", "'TRANSACTION'", "'TRANSFORM'", "'TRUNCATE'", + "'TYPE'", "'UNDROP'", "'UNIQUE'", "'UNKNOWN'", "'UNTIL'", "'UPDATE'", + "'VALUES'", "'VECTOR'", "'VIEW'", "'VIEWS'", "'VOLATILE'", "'WEIGHT'", + "'WHILE'", "'WRITE'", "'ZONE'", "'DESCRIPTOR'", "'INTERLEAVE'", "'NULL_FILTERED'", + "'PARENT'", "'NEW'", "'END'", "'CASE'", "'WHEN'", "'THEN'", "'ELSE'", + "'CAST'", "'EXTRACT'", "'COLLATE'", "'IF'", "'GROUPING'", "'HAVING'", + "'GROUP'", "'ROLLUP'", "'CUBE'", "'HASH'", "'PROTO'", "'PARTITION'", + "'IGNORE'", "'RESPECT'", "'ROWS'", "'OVER'", "'BETWEEN'", "'UNBOUNDED'", + "'CURRENT'", "'PRECEDING'", "'FOLLOWING'", "'NATURAL'", "'QUALIFY'", + "'DEFAULT'", "'SLASH'", "'MATCH_RECOGNIZE'", "'DEFINE'", "'LOOKUP'", + "'WHERE'", "'WINDOW'", "'TO'", "'EXISTS'", "'ANY'", "'SOME'", "'LIKE'", + "'IS'", "'NO'", "'INTO'", "'ASSERT_ROWS_MODIFIED'", "'CONFLICT'", "'NOTHING'", + "'MERGE'", "'CREATE'", "'ENUM'", "'DESTINATION'", "'PROPERTY'", "'GRAPH'", + "'NODE'", "'PROPERTIES'", "'LABEL'", "'EDGE'", "'NEXT'", "'ASCENDING'", + "'DESCENDING'", "'SKIP'", "'SHORTEST'", "'PATH'", "'PATHS'", "'WALK'", + "'TRAIL'", "'ACYCLIC'", "'OPTIONAL'", "'LET'", + } + staticData.SymbolicNames = []string{ + "", "EQUAL_OPERATOR", "NOT_EQUAL_OPERATOR", "NOT_EQUAL2_OPERATOR", "LT_OPERATOR", + "LE_OPERATOR", "GT_OPERATOR", "GE_OPERATOR", "KL_OPERATOR", "KR_OPERATOR", + "PLUS_OPERATOR", "MINUS_OPERATOR", "MULTIPLY_OPERATOR", "DIVIDE_OPERATOR", + "BITWISE_NOT_OPERATOR", "EXCLAMATION_OPERATOR", "MODULO_OPERATOR", "COMMA_SYMBOL", + "DOT_SYMBOL", "LC_BRACKET_SYMBOL", "RC_BRACKET_SYMBOL", "LR_BRACKET_SYMBOL", + "RR_BRACKET_SYMBOL", "LS_BRACKET_SYMBOL", "RS_BRACKET_SYMBOL", "STROKE_SYMBOL", + "COLON_SYMBOL", "SEMI_SYMBOL", "SINGLE_QUOTE_SYMBOL", "SINGLE_QUOTE_3_SYMBOL", + "DOUBLE_QUOTE_SYMBOL", "DOUBLE_QUOTE_3_SYMBOL", "BACKQUOTE_SYMBOL", + "QUESTION_SYMBOL", "AT_SYMBOL", "ATAT_SYMBOL", "EQUAL_GT_BRACKET_SYMBOL", + "SUB_GT_BRACKET_SYMBOL", "PLUS_EQUAL_SYMBOL", "SUB_EQUAL_SYMBOL", "PIPE_SYMBOL", + "CIRCUMFLEX_SYMBOL", "BIT_AND_SYMBOL", "BOOL_OR_SYMBOL", "STRING_LITERAL", + "BYTES_LITERAL", "UNCLOSED_STRING_LITERAL", "UNCLOSED_TRIPLE_QUOTED_STRING_LITERAL", + "UNCLOSED_RAW_STRING_LITERAL", "UNCLOSED_TRIPLE_QUOTED_RAW_STRING_LITERAL", + "UNCLOSED_BYTES_LITERAL", "UNCLOSED_TRIPLE_QUOTED_BYTES_LITERAL", "UNCLOSED_RAW_BYTES_LITERAL", + "UNCLOSED_TRIPLE_QUOTED_RAW_BYTES_LITERAL", "FLOATING_POINT_LITERAL", + "INTEGER_LITERAL", "ARRAY_SYMBOL", "ALL_SYMBOL", "AS_SYMBOL", "ASC_SYMBOL", + "BY_SYMBOL", "CROSS_SYMBOL", "JOIN_SYMBOL", "DELTA_SYMBOL", "DESC_SYMBOL", + "DIFFERENTIAL_PRIVACY_SYMBOL", "DISTINCT_SYMBOL", "EPSILON_SYMBOL", + "EXCEPT_SYMBOL", "EXCLUDE_SYMBOL", "FOR_SYMBOL", "FROM_SYMBOL", "FULL_SYMBOL", + "IN_SYMBOL", "INCLUDE_SYMBOL", "INNER_SYMBOL", "INTERSECT_SYMBOL", "LEFT_SYMBOL", + "LIMIT_SYMBOL", "MAX_GROUPS_CONTRIBUTED_SYMBOL", "NULL_SYMBOL", "NULLS_SYMBOL", + "OF_SYMBOL", "OFFSET_SYMBOL", "ON_SYMBOL", "OPTIONS_SYMBOL", "ORDER_SYMBOL", + "OUTER_SYMBOL", "PERCENT_SYMBOL", "PIVOT_SYMBOL", "PRIVACY_UNIT_COLUMN_SYMBOL", + "RIGHT_SYMBOL", "RECURSIVE_SYMBOL", "REPLACE_SYMBOL", "UNPIVOT_SYMBOL", + "SELECT_SYMBOL", "STRUCT_SYMBOL", "SYSTEM_SYMBOL", "SYSTEM_TIME_SYMBOL", + "TABLESAMPLE_SYMBOL", "UNION_SYMBOL", "UNNEST_SYMBOL", "USING_SYMBOL", + "VALUE_SYMBOL", "WITH_SYMBOL", "TRUE_SYMBOL", "FALSE_SYMBOL", "NUMERIC_SYMBOL", + "DECIMAL_SYMBOL", "BIGNUMERIC_SYMBOL", "BIGDECIMAL_SYMBOL", "NOT_SYMBOL", + "AND_SYMBOL", "OR_SYMBOL", "JSON_SYMBOL", "DATE_SYMBOL", "TIME_SYMBOL", + "DATETIME_SYMBOL", "TIMESTAMP_SYMBOL", "RANGE_SYMBOL", "INTERVAL_SYMBOL", + "SIMPLE_SYMBOL", "ABORT_SYMBOL", "ACCESS_SYMBOL", "ACTION_SYMBOL", "AGGREGATE_SYMBOL", + "ADD_SYMBOL", "ALTER_SYMBOL", "ALWAYS_SYMBOL", "ANALYZE_SYMBOL", "APPROX_SYMBOL", + "ARE_SYMBOL", "ASSERT_SYMBOL", "BATCH_SYMBOL", "BEGIN_SYMBOL", "BREAK_SYMBOL", + "CALL_SYMBOL", "CASCADE_SYMBOL", "CHECK_SYMBOL", "CLAMPED_SYMBOL", "CLONE_SYMBOL", + "COPY_SYMBOL", "CLUSTER_SYMBOL", "COLUMN_SYMBOL", "COLUMNS_SYMBOL", + "COMMIT_SYMBOL", "CONNECTION_SYMBOL", "CONSTANT_SYMBOL", "CONSTRAINT_SYMBOL", + "CONTINUE_SYMBOL", "CORRESPONDING_SYMBOL", "CYCLE_SYMBOL", "DATA_SYMBOL", + "DATABASE_SYMBOL", "DECLARE_SYMBOL", "DEFINER_SYMBOL", "DELETE_SYMBOL", + "DELETION_SYMBOL", "DEPTH_SYMBOL", "DESCRIBE_SYMBOL", "DETERMINISTIC_SYMBOL", + "DO_SYMBOL", "DROP_SYMBOL", "ELSEIF_SYMBOL", "ENFORCED_SYMBOL", "ERROR_SYMBOL", + "EXCEPTION_SYMBOL", "EXECUTE_SYMBOL", "EXPLAIN_SYMBOL", "EXPORT_SYMBOL", + "EXTEND_SYMBOL", "EXTERNAL_SYMBOL", "FILES_SYMBOL", "FILTER_SYMBOL", + "FILL_SYMBOL", "FIRST_SYMBOL", "FOREIGN_SYMBOL", "FORMAT_SYMBOL", "FUNCTION_SYMBOL", + "GENERATED_SYMBOL", "GRANT_SYMBOL", "GROUP_ROWS_SYMBOL", "HIDDEN_SYMBOL", + "IDENTITY_SYMBOL", "IMMEDIATE_SYMBOL", "IMMUTABLE_SYMBOL", "IMPORT_SYMBOL", + "INCREMENT_SYMBOL", "INDEX_SYMBOL", "INOUT_SYMBOL", "INPUT_SYMBOL", + "INSERT_SYMBOL", "INVOKER_SYMBOL", "ISOLATION_SYMBOL", "ITERATE_SYMBOL", + "KEY_SYMBOL", "LANGUAGE_SYMBOL", "LAST_SYMBOL", "LEAVE_SYMBOL", "LEVEL_SYMBOL", + "LOAD_SYMBOL", "LOOP_SYMBOL", "MACRO_SYMBOL", "MAP_SYMBOL", "MATCH_SYMBOL", + "KW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL", "MATCHED_SYMBOL", "MATERIALIZED_SYMBOL", + "MAX_SYMBOL", "MAXVALUE_SYMBOL", "MEASURES_SYMBOL", "MESSAGE_SYMBOL", + "METADATA_SYMBOL", "MIN_SYMBOL", "MINVALUE_SYMBOL", "MODEL_SYMBOL", + "MODULE_SYMBOL", "ONLY_SYMBOL", "OUT_SYMBOL", "OUTPUT_SYMBOL", "OVERWRITE_SYMBOL", + "PARTITIONS_SYMBOL", "PATTERN_SYMBOL", "POLICIES_SYMBOL", "POLICY_SYMBOL", + "PRIMARY_SYMBOL", "PRIVATE_SYMBOL", "PRIVILEGE_SYMBOL", "PRIVILEGES_SYMBOL", + "PROCEDURE_SYMBOL", "PROJECT_SYMBOL", "PUBLIC_SYMBOL", "RAISE_SYMBOL", + "READ_SYMBOL", "REFERENCES_SYMBOL", "REMOTE_SYMBOL", "REMOVE_SYMBOL", + "RENAME_SYMBOL", "REPEAT_SYMBOL", "REPEATABLE_SYMBOL", "REPLACE_FIELDS_SYMBOL", + "REPLICA_SYMBOL", "REPORT_SYMBOL", "RESTRICT_SYMBOL", "RESTRICTION_SYMBOL", + "RETURNS_SYMBOL", "RETURN_SYMBOL", "REVOKE_SYMBOL", "ROLLBACK_SYMBOL", + "ROW_SYMBOL", "RUN_SYMBOL", "SAFE_CAST_SYMBOL", "SCHEMA_SYMBOL", "SEARCH_SYMBOL", + "SECURITY_SYMBOL", "SEQUENCE_SYMBOL", "SETS_SYMBOL", "SET_SYMBOL", "SHOW_SYMBOL", + "SNAPSHOT_SYMBOL", "SOURCE_SYMBOL", "SQL_SYMBOL", "STABLE_SYMBOL", "START_SYMBOL", + "STATIC_DESCRIBE_SYMBOL", "STORED_SYMBOL", "STORING_SYMBOL", "STRICT_SYMBOL", + "TABLE_SYMBOL", "TABLES_SYMBOL", "TARGET_SYMBOL", "TEMP_SYMBOL", "TEMPORARY_SYMBOL", + "TRANSACTION_SYMBOL", "TRANSFORM_SYMBOL", "TRUNCATE_SYMBOL", "TYPE_SYMBOL", + "UNDROP_SYMBOL", "UNIQUE_SYMBOL", "UNKNOWN_SYMBOL", "UNTIL_SYMBOL", + "UPDATE_SYMBOL", "VALUES_SYMBOL", "VECTOR_SYMBOL", "VIEW_SYMBOL", "VIEWS_SYMBOL", + "VOLATILE_SYMBOL", "WEIGHT_SYMBOL", "WHILE_SYMBOL", "WRITE_SYMBOL", + "ZONE_SYMBOL", "DESCRIPTOR_SYMBOL", "INTERLEAVE_SYMBOL", "NULL_FILTERED_SYMBOL", + "PARENT_SYMBOL", "NEW_SYMBOL", "END_SYMBOL", "CASE_SYMBOL", "WHEN_SYMBOL", + "THEN_SYMBOL", "ELSE_SYMBOL", "CAST_SYMBOL", "EXTRACT_SYMBOL", "COLLATE_SYMBOL", + "IF_SYMBOL", "GROUPING_SYMBOL", "HAVING_SYMBOL", "GROUP_SYMBOL", "ROLLUP_SYMBOL", + "CUBE_SYMBOL", "HASH_SYMBOL", "PROTO_SYMBOL", "PARTITION_SYMBOL", "IGNORE_SYMBOL", + "RESPECT_SYMBOL", "ROWS_SYMBOL", "OVER_SYMBOL", "BETWEEN_SYMBOL", "UNBOUNDED_SYMBOL", + "CURRENT_SYMBOL", "PRECEDING_SYMBOL", "FOLLOWING_SYMBOL", "NATURAL_SYMBOL", + "QUALIFY_SYMBOL", "DEFAULT_SYMBOL", "SLASH_SYMBOL", "MATCH_RECOGNIZE_SYMBOL", + "DEFINE_SYMBOL", "LOOKUP_SYMBOL", "WHERE_SYMBOL", "WINDOW_SYMBOL", "TO_SYMBOL", + "EXISTS_SYMBOL", "ANY_SYMBOL", "SOME_SYMBOL", "LIKE_SYMBOL", "IS_SYMBOL", + "NO_SYMBOL", "INTO_SYMBOL", "ASSERT_ROWS_MODIFIED_SYMBOL", "CONFLICT_SYMBOL", + "NOTHING_SYMBOL", "MERGE_SYMBOL", "CREATE_SYMBOL", "ENUM_SYMBOL", "DESTINATION_SYMBOL", + "PROPERTY_SYMBOL", "GRAPH_SYMBOL", "NODE_SYMBOL", "PROPERTIES_SYMBOL", + "LABEL_SYMBOL", "EDGE_SYMBOL", "NEXT_SYMBOL", "ASCENDING_SYMBOL", "DESCENDING_SYMBOL", + "SKIP_SYMBOL", "SHORTEST_SYMBOL", "PATH_SYMBOL", "PATHS_SYMBOL", "WALK_SYMBOL", + "TRAIL_SYMBOL", "ACYCLIC_SYMBOL", "OPTIONAL_SYMBOL", "LET_SYMBOL", "IDENTIFIER", + "UNCLOSED_ESCAPED_IDENTIFIER", "WHITESPACE", "COMMENT", + } + staticData.RuleNames = []string{ + "root", "stmts", "unterminated_sql_statement", "sql_statement_body", + "gql_statement", "graph_operation_block", "graph_composite_query_block", + "graph_composite_query_prefix", "graph_set_operation_metadata", "graph_linear_query_operation", + "graph_linear_operator_list", "graph_linear_operator", "graph_sample_clause", + "opt_graph_sample_clause_suffix", "graph_for_operator", "opt_with_offset_and_alias_with_required_as", + "graph_with_operator", "graph_page_operator", "graph_order_by_operator", + "graph_filter_operator", "graph_let_operator", "graph_let_variable_definition_list", + "graph_let_variable_definition", "graph_optional_match_operator", "graph_match_operator", + "graph_pattern", "graph_path_pattern_list", "graph_path_pattern", "graph_path_pattern_expr", + "graph_path_factor", "graph_quantified_path_primary", "graph_path_primary", + "graph_parenthesized_path_pattern", "graph_element_pattern", "graph_edge_pattern", + "graph_node_pattern", "graph_element_pattern_filler", "graph_property_specification", + "graph_property_name_and_value", "opt_is_label_expression", "label_expression", + "label_primary", "parenthesized_label_expression", "opt_graph_element_identifier", + "opt_graph_path_mode_prefix", "path_or_paths", "opt_graph_path_mode", + "opt_graph_search_prefix", "opt_path_variable_assignment", "graph_identifier", + "graph_return_operator", "graph_page_clause", "graph_order_by_clause", + "graph_ordering_expression", "opt_graph_asc_or_desc", "graph_return_item_list", + "graph_return_item", "undrop_statement", "module_statement", "import_statement", + "opt_as_or_into_alias", "path_expression_or_string", "import_type", + "call_statement", "drop_statement", "opt_drop_mode", "drop_all_row_access_policies_statement", + "show_statement", "opt_like_string_literal", "show_target", "rename_statement", + "revoke_statement", "grant_statement", "privileges", "export_metadata_statement", + "export_model_statement", "export_data_statement", "export_data_no_query", + "explain_statement", "execute_immediate", "opt_execute_into_clause", + "opt_execute_using_clause", "execute_using_argument_list", "execute_using_argument", + "describe_statement", "describe_info", "opt_from_path_expression", "describe_keyword", + "define_table_statement", "create_entity_statement", "opt_generic_entity_body", + "create_view_statement", "query_or_replica_source", "column_with_options_list", + "column_with_options", "create_table_statement", "opt_ttl_clause", "opt_copy_table", + "copy_data_source", "opt_clone_table", "opt_spanner_table_options", + "opt_spanner_interleave_in_parent_clause", "spanner_primary_key", "create_table_function_statement", + "opt_as_query_or_string", "unordered_language_options", "opt_function_parameters", + "create_snapshot_statement", "create_external_schema_statement", "create_schema_statement", + "create_property_graph_statement", "opt_edge_table_clause", "element_table_list", + "element_table_definition", "opt_label_and_properties_clause", "label_and_properties_list", + "label_and_properties", "properties_clause", "derived_property_list", + "derived_property", "opt_except_column_list", "properties_all_columns", + "opt_dest_node_table_clause", "opt_source_node_table_clause", "opt_key_clause", + "create_model_statement", "opt_input_output_clause", "opt_transform_clause", + "opt_as_query_or_aliased_query_list", "aliased_query_list", "as_query", + "create_external_table_function_statement", "create_external_table_statement", + "opt_default_collate_clause", "opt_like_path_expression", "create_row_access_policy_statement", + "filter_using_clause", "create_row_access_policy_grant_to_clause", "create_privilege_restriction_statement", + "restrict_to_clause", "possibly_empty_grantee_list", "create_index_statement", + "opt_create_index_statement_suffix", "spanner_index_interleave_clause", + "index_storing_list", "index_storing_expression_list", "index_order_by_and_options", + "index_all_columns", "opt_with_column_options", "all_column_column_options", + "column_ordering_and_options_expr", "index_unnest_expression_list", + "unnest_expression_with_opt_alias_and_offset", "on_path_expression", + "index_type", "opt_spanner_null_filtered", "create_procedure_statement", + "begin_end_block_or_language_as_code", "begin_end_block", "opt_exception_handler", + "statement_list", "unterminated_non_empty_statement_list", "unterminated_statement", + "unterminated_script_statement", "label", "unterminated_unlabeled_script_statement", + "for_in_statement", "repeat_statement", "until_clause", "loop_statement", + "while_statement", "raise_statement", "return_statement", "continue_statement", + "variable_declaration", "break_statement", "case_statement", "when_then_clauses", + "if_statement", "elseif_clauses", "opt_else", "opt_as_code", "opt_external_security_clause", + "external_security_clause_kind", "procedure_parameters", "procedure_parameter", + "procedure_parameter_termination", "opt_procedure_parameter_mode", "create_function_statement", + "opt_determinism_level", "opt_sql_security_clause", "sql_security_clause_kind", + "as_sql_function_body_or_string", "sql_function_body", "unordered_options_body", + "opt_language_or_remote_with_connection", "language", "remote_with_connection_clause", + "with_connection_clause", "opt_function_returns", "opt_returns", "function_declaration", + "function_parameters", "function_parameter", "opt_not_aggregate", "opt_default_expression", + "type_or_tvf_schema", "tvf_schema", "tvf_schema_column", "templated_parameter_type", + "templated_parameter_kind", "opt_aggregate", "create_database_statement", + "create_connection_statement", "create_constant_statement", "opt_or_replace", + "opt_create_scope", "run_batch_statement", "abort_batch_statement", + "start_batch_statement", "rollback_statement", "commit_statement", "set_statement", + "identifier_list", "begin_statement", "begin_transaction_keywords", + "transaction_mode_list", "transaction_mode", "truncate_statement", "merge_statement", + "merge_source", "merge_when_clause", "merge_action", "merge_insert_value_list_or_source_row", + "by_target", "opt_and_expression", "statement_level_hint", "query_statement", + "dml_statement", "update_statement", "delete_statement", "insert_statement", + "on_conflict_clause", "opt_where_expression", "opt_conflict_target", + "update_item_list", "update_item", "update_set_value", "nested_dml_statement", + "insert_values_list_or_table_clause", "table_clause_unreversed", "table_clause_no_keyword", + "opt_returning_clause", "opt_assert_rows_modified", "insert_values_or_query", + "insert_values_list", "insert_values_row", "expression_or_default", + "insert_statement_prefix", "maybe_dashed_generalized_path_expression", + "opt_into", "opt_or_ignore_replace_update", "alter_statement", "analyze_statement", + "assert_statement", "aux_load_data_statement", "clone_data_statement", + "clone_data_source_list", "clone_data_source", "opt_external_table_with_clauses", + "with_partition_columns_clause", "aux_load_data_from_files_options_list", + "cluster_by_clause_prefix_no_hint", "load_data_partitions_clause", "maybe_dashed_path_expression_with_scope", + "table_element_list", "table_element", "table_constraint_definition", + "append_or_overwrite", "opt_description", "table_and_column_info_list", + "table_and_column_info", "row_access_policy_alter_action_list", "row_access_policy_alter_action", + "grant_to_clause", "grantee_list", "privilege_list", "privilege", "path_expression_list_with_parens", + "privilege_name", "generic_entity_type", "generic_entity_type_unchecked", + "schema_object_kind", "alter_action_list", "alter_action", "spanner_set_on_delete_action", + "spanner_alter_column_action", "spanner_generated_or_default", "generic_sub_entity_type", + "sub_entity_type_identifier", "fill_using_expression", "column_position", + "table_column_definition", "column_attributes", "column_attribute", + "primary_key_column_attribute", "foreign_key_column_attribute", "hidden_column_attribute", + "opt_constraint_identity", "table_column_schema", "opt_column_info", + "invalid_generated_column", "invalid_default_column", "default_column_info", + "generated_column_info", "identity_column_info", "opt_start_with", "opt_increment_by", + "opt_maxvalue", "opt_minvalue", "opt_cycle", "signed_numeric_literal", + "stored_mode", "generated_mode", "column_schema_inner", "raw_column_schema_inner", + "range_column_schema_inner", "struct_column_schema_inner", "struct_column_field", + "simple_column_schema_inner", "array_column_schema_inner", "field_schema", + "opt_field_attributes", "not_null_column_attribute", "primary_key_or_table_constraint_spec", + "opt_if_not_exists", "primary_key_spec", "primary_key_element_list", + "primary_key_element", "table_constraint_spec", "foreign_key_reference", + "opt_foreign_key_action", "foreign_key_on_update", "foreign_key_on_delete", + "foreign_key_action", "opt_foreign_key_match", "foreign_key_match_mode", + "column_list", "opt_options_list", "constraint_enforcement", "generic_entity_body", + "opt_if_exists", "table_or_table_function", "query", "query_without_pipe_operators", + "bad_keyword_after_from_query", "bad_keyword_after_from_query_allows_parens", + "with_clause_with_trailing_comma", "select_or_from_keyword", "query_primary_or_set_operation", + "query_set_operation", "query_set_operation_prefix", "query_set_operation_item", + "query_primary", "set_operation_metadata", "opt_column_match_suffix", + "opt_strict", "all_or_distinct", "query_set_operation_type", "opt_corresponding_outer_mode", + "opt_outer", "with_clause", "aliased_query", "opt_aliased_query_modifiers", + "recursion_depth_modifier", "possibly_unbounded_int_literal_or_parameter", + "int_literal_or_parameter", "order_by_clause", "order_by_clause_prefix", + "ordering_expression", "select", "opt_clauses_following_from", "opt_clauses_following_where", + "opt_clauses_following_group_by", "window_clause", "window_clause_prefix", + "window_definition", "where_clause", "having_clause", "group_by_clause", + "group_by_all", "select_clause", "opt_select_as_clause", "opt_select_with", + "from_clause", "from_clause_contents", "from_clause_contents_suffix", + "table_primary", "tvf_with_suffixes", "pivot_or_unpivot_clause_and_aliases", + "as_alias", "sample_clause", "opt_sample_clause_suffix", "repeatable_clause", + "possibly_cast_int_literal_or_parameter", "cast_int_literal_or_parameter", + "sample_size", "sample_size_value", "sample_size_unit", "partition_by_clause_prefix_no_hint", + "match_recognize_clause", "row_pattern_expr", "row_pattern_concatenation", + "row_pattern_factor", "select_list_prefix_with_as_aliases", "select_column_expr_with_as_alias", + "table_subquery", "join", "join_item", "on_or_using_clause_list", "on_or_using_clause", + "using_clause", "join_hint", "table_path_expression", "opt_at_system_time", + "opt_with_offset_and_alias", "opt_pivot_or_unpivot_clause_and_alias", + "table_path_expression_base", "maybe_slashed_or_dashed_path_expression", + "maybe_dashed_path_expression", "dashed_path_expression", "dashed_identifier", + "slashed_identifier", "identifier_or_integer", "slashed_identifier_separator", + "slashed_path_expression", "unnest_expression", "unnest_expression_prefix", + "opt_array_zip_mode", "expression_with_opt_alias", "tvf_prefix", "tvf_argument", + "connection_clause", "path_expression_or_default", "descriptor_argument", + "descriptor_column_list", "descriptor_column", "table_clause", "model_clause", + "qualify_clause_nonreserved", "unpivot_clause", "unpivot_in_item_list", + "unpivot_in_item_list_prefix", "unpivot_in_item", "opt_as_string_or_integer", + "path_expression_list_with_opt_parens", "path_expression_list", "unpivot_nulls_filter", + "pivot_clause", "pivot_expression_list", "pivot_expression", "pivot_value_list", + "pivot_value", "tvf_prefix_no_args", "join_type", "opt_natural", "on_clause", + "select_list", "select_list_item", "select_column_star", "select_column_expr", + "select_column_dot_star", "star_modifiers", "star_except_list", "star_replace_list", + "star_replace_item", "expression", "expression_higher_prec_than_and", + "expression_maybe_parenthesized_not_a_query", "parenthesized_in_rhs", + "unary_operator", "comparative_operator", "shift_operator", "additive_operator", + "multiplicative_operator", "is_operator", "between_operator", "in_operator", + "distinct_operator", "parenthesized_query", "parenthesized_expression_not_a_query", + "parenthesized_anysomeall_list_in_rhs", "and_expression", "in_list_two_or_more_prefix", + "any_some_all", "like_operator", "expression_subquery_with_keyword", + "struct_constructor", "struct_constructor_prefix_with_keyword", "struct_constructor_arg", + "struct_constructor_prefix_without_keyword", "struct_constructor_prefix_with_keyword_no_arg", + "interval_expression", "function_call_expression_with_clauses", "function_call_expression_with_clauses_suffix", + "over_clause", "window_specification", "opt_window_frame_clause", "window_frame_bound", + "preceding_or_following", "frame_unit", "partition_by_clause", "partition_by_clause_prefix", + "with_group_rows", "with_report_modifier", "clamped_between_modifier", + "with_report_format", "options_list", "options_list_prefix", "options_entry", + "expression_or_proto", "options_assignment_operator", "opt_null_handling_modifier", + "function_call_argument", "sequence_arg", "named_argument", "lambda_argument", + "lambda_argument_list", "limit_offset_clause", "opt_having_or_group_by_modifier", + "group_by_clause_prefix", "group_by_preamble", "opt_and_order", "hint", + "hint_with_body", "hint_with_body_prefix", "hint_entry", "identifier_in_hints", + "extra_identifier_in_hints_name", "grouping_item", "grouping_set_list", + "grouping_set", "cube_list", "rollup_list", "opt_as_alias_with_required_as", + "opt_grouping_item_order", "opt_selection_item_order", "asc_or_desc", + "null_order", "function_name_from_keyword", "replace_fields_expression", + "replace_fields_prefix", "replace_fields_arg", "generalized_path_expression", + "generalized_extension_path", "with_expression", "with_expression_variable_prefix", + "with_expression_variable", "extract_expression", "extract_expression_base", + "opt_format", "opt_at_time_zone", "cast_expression", "case_expression", + "case_expression_prefix", "case_value_expression_prefix", "case_no_value_expression_prefix", + "struct_braced_constructor", "braced_new_constructor", "braced_constructor", + "braced_constructor_start", "braced_constructor_prefix", "braced_constructor_field", + "braced_constructor_lhs", "braced_constructor_field_value", "braced_constructor_extension", + "new_constructor", "new_constructor_prefix", "new_constructor_prefix_no_arg", + "new_constructor_arg", "array_constructor", "array_constructor_prefix", + "array_constructor_prefix_no_expressions", "range_literal", "range_type", + "type", "collate_clause", "string_literal_or_parameter", "system_variable_expression", + "parameter_expression", "named_parameter_expression", "opt_type_parameters", + "type_parameters_prefix", "type_parameter", "raw_type", "map_type", + "function_type", "function_type_prefix", "type_name", "path_expression", + "identifier", "keyword_as_identifier", "common_keyword_as_identifier", + "token_identifier", "struct_type", "struct_type_prefix", "struct_field", + "array_type", "template_type_open", "template_type_close", "date_or_time_literal", + "date_or_time_literal_kind", "floating_point_literal", "json_literal", + "bignumeric_literal", "bignumeric_literal_prefix", "numeric_literal", + "numeric_literal_prefix", "integer_literal", "bytes_literal", "null_literal", + "boolean_literal", "string_literal", "string_literal_component", "bytes_literal_component", + } + staticData.PredictionContextCache = antlr.NewPredictionContextCache() + staticData.serializedATN = []int32{ + 4, 1, 367, 6994, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, + 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, + 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, + 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, + 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, + 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, + 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, + 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, + 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, + 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, + 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, + 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, + 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, + 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, + 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, + 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, + 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, + 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, + 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, + 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, + 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, + 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, + 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, + 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, + 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, + 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, + 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, + 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, + 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, + 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, + 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, + 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2, + 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, 7, + 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, 2, + 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, 7, + 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175, 2, + 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, 180, 7, + 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, 184, 2, + 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, 189, 7, + 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, 193, 2, + 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 2, 198, 7, + 198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, 7, 201, 2, 202, 7, 202, 2, + 203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, 2, 206, 7, 206, 2, 207, 7, + 207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, 7, 210, 2, 211, 7, 211, 2, + 212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, 2, 215, 7, 215, 2, 216, 7, + 216, 2, 217, 7, 217, 2, 218, 7, 218, 2, 219, 7, 219, 2, 220, 7, 220, 2, + 221, 7, 221, 2, 222, 7, 222, 2, 223, 7, 223, 2, 224, 7, 224, 2, 225, 7, + 225, 2, 226, 7, 226, 2, 227, 7, 227, 2, 228, 7, 228, 2, 229, 7, 229, 2, + 230, 7, 230, 2, 231, 7, 231, 2, 232, 7, 232, 2, 233, 7, 233, 2, 234, 7, + 234, 2, 235, 7, 235, 2, 236, 7, 236, 2, 237, 7, 237, 2, 238, 7, 238, 2, + 239, 7, 239, 2, 240, 7, 240, 2, 241, 7, 241, 2, 242, 7, 242, 2, 243, 7, + 243, 2, 244, 7, 244, 2, 245, 7, 245, 2, 246, 7, 246, 2, 247, 7, 247, 2, + 248, 7, 248, 2, 249, 7, 249, 2, 250, 7, 250, 2, 251, 7, 251, 2, 252, 7, + 252, 2, 253, 7, 253, 2, 254, 7, 254, 2, 255, 7, 255, 2, 256, 7, 256, 2, + 257, 7, 257, 2, 258, 7, 258, 2, 259, 7, 259, 2, 260, 7, 260, 2, 261, 7, + 261, 2, 262, 7, 262, 2, 263, 7, 263, 2, 264, 7, 264, 2, 265, 7, 265, 2, + 266, 7, 266, 2, 267, 7, 267, 2, 268, 7, 268, 2, 269, 7, 269, 2, 270, 7, + 270, 2, 271, 7, 271, 2, 272, 7, 272, 2, 273, 7, 273, 2, 274, 7, 274, 2, + 275, 7, 275, 2, 276, 7, 276, 2, 277, 7, 277, 2, 278, 7, 278, 2, 279, 7, + 279, 2, 280, 7, 280, 2, 281, 7, 281, 2, 282, 7, 282, 2, 283, 7, 283, 2, + 284, 7, 284, 2, 285, 7, 285, 2, 286, 7, 286, 2, 287, 7, 287, 2, 288, 7, + 288, 2, 289, 7, 289, 2, 290, 7, 290, 2, 291, 7, 291, 2, 292, 7, 292, 2, + 293, 7, 293, 2, 294, 7, 294, 2, 295, 7, 295, 2, 296, 7, 296, 2, 297, 7, + 297, 2, 298, 7, 298, 2, 299, 7, 299, 2, 300, 7, 300, 2, 301, 7, 301, 2, + 302, 7, 302, 2, 303, 7, 303, 2, 304, 7, 304, 2, 305, 7, 305, 2, 306, 7, + 306, 2, 307, 7, 307, 2, 308, 7, 308, 2, 309, 7, 309, 2, 310, 7, 310, 2, + 311, 7, 311, 2, 312, 7, 312, 2, 313, 7, 313, 2, 314, 7, 314, 2, 315, 7, + 315, 2, 316, 7, 316, 2, 317, 7, 317, 2, 318, 7, 318, 2, 319, 7, 319, 2, + 320, 7, 320, 2, 321, 7, 321, 2, 322, 7, 322, 2, 323, 7, 323, 2, 324, 7, + 324, 2, 325, 7, 325, 2, 326, 7, 326, 2, 327, 7, 327, 2, 328, 7, 328, 2, + 329, 7, 329, 2, 330, 7, 330, 2, 331, 7, 331, 2, 332, 7, 332, 2, 333, 7, + 333, 2, 334, 7, 334, 2, 335, 7, 335, 2, 336, 7, 336, 2, 337, 7, 337, 2, + 338, 7, 338, 2, 339, 7, 339, 2, 340, 7, 340, 2, 341, 7, 341, 2, 342, 7, + 342, 2, 343, 7, 343, 2, 344, 7, 344, 2, 345, 7, 345, 2, 346, 7, 346, 2, + 347, 7, 347, 2, 348, 7, 348, 2, 349, 7, 349, 2, 350, 7, 350, 2, 351, 7, + 351, 2, 352, 7, 352, 2, 353, 7, 353, 2, 354, 7, 354, 2, 355, 7, 355, 2, + 356, 7, 356, 2, 357, 7, 357, 2, 358, 7, 358, 2, 359, 7, 359, 2, 360, 7, + 360, 2, 361, 7, 361, 2, 362, 7, 362, 2, 363, 7, 363, 2, 364, 7, 364, 2, + 365, 7, 365, 2, 366, 7, 366, 2, 367, 7, 367, 2, 368, 7, 368, 2, 369, 7, + 369, 2, 370, 7, 370, 2, 371, 7, 371, 2, 372, 7, 372, 2, 373, 7, 373, 2, + 374, 7, 374, 2, 375, 7, 375, 2, 376, 7, 376, 2, 377, 7, 377, 2, 378, 7, + 378, 2, 379, 7, 379, 2, 380, 7, 380, 2, 381, 7, 381, 2, 382, 7, 382, 2, + 383, 7, 383, 2, 384, 7, 384, 2, 385, 7, 385, 2, 386, 7, 386, 2, 387, 7, + 387, 2, 388, 7, 388, 2, 389, 7, 389, 2, 390, 7, 390, 2, 391, 7, 391, 2, + 392, 7, 392, 2, 393, 7, 393, 2, 394, 7, 394, 2, 395, 7, 395, 2, 396, 7, + 396, 2, 397, 7, 397, 2, 398, 7, 398, 2, 399, 7, 399, 2, 400, 7, 400, 2, + 401, 7, 401, 2, 402, 7, 402, 2, 403, 7, 403, 2, 404, 7, 404, 2, 405, 7, + 405, 2, 406, 7, 406, 2, 407, 7, 407, 2, 408, 7, 408, 2, 409, 7, 409, 2, + 410, 7, 410, 2, 411, 7, 411, 2, 412, 7, 412, 2, 413, 7, 413, 2, 414, 7, + 414, 2, 415, 7, 415, 2, 416, 7, 416, 2, 417, 7, 417, 2, 418, 7, 418, 2, + 419, 7, 419, 2, 420, 7, 420, 2, 421, 7, 421, 2, 422, 7, 422, 2, 423, 7, + 423, 2, 424, 7, 424, 2, 425, 7, 425, 2, 426, 7, 426, 2, 427, 7, 427, 2, + 428, 7, 428, 2, 429, 7, 429, 2, 430, 7, 430, 2, 431, 7, 431, 2, 432, 7, + 432, 2, 433, 7, 433, 2, 434, 7, 434, 2, 435, 7, 435, 2, 436, 7, 436, 2, + 437, 7, 437, 2, 438, 7, 438, 2, 439, 7, 439, 2, 440, 7, 440, 2, 441, 7, + 441, 2, 442, 7, 442, 2, 443, 7, 443, 2, 444, 7, 444, 2, 445, 7, 445, 2, + 446, 7, 446, 2, 447, 7, 447, 2, 448, 7, 448, 2, 449, 7, 449, 2, 450, 7, + 450, 2, 451, 7, 451, 2, 452, 7, 452, 2, 453, 7, 453, 2, 454, 7, 454, 2, + 455, 7, 455, 2, 456, 7, 456, 2, 457, 7, 457, 2, 458, 7, 458, 2, 459, 7, + 459, 2, 460, 7, 460, 2, 461, 7, 461, 2, 462, 7, 462, 2, 463, 7, 463, 2, + 464, 7, 464, 2, 465, 7, 465, 2, 466, 7, 466, 2, 467, 7, 467, 2, 468, 7, + 468, 2, 469, 7, 469, 2, 470, 7, 470, 2, 471, 7, 471, 2, 472, 7, 472, 2, + 473, 7, 473, 2, 474, 7, 474, 2, 475, 7, 475, 2, 476, 7, 476, 2, 477, 7, + 477, 2, 478, 7, 478, 2, 479, 7, 479, 2, 480, 7, 480, 2, 481, 7, 481, 2, + 482, 7, 482, 2, 483, 7, 483, 2, 484, 7, 484, 2, 485, 7, 485, 2, 486, 7, + 486, 2, 487, 7, 487, 2, 488, 7, 488, 2, 489, 7, 489, 2, 490, 7, 490, 2, + 491, 7, 491, 2, 492, 7, 492, 2, 493, 7, 493, 2, 494, 7, 494, 2, 495, 7, + 495, 2, 496, 7, 496, 2, 497, 7, 497, 2, 498, 7, 498, 2, 499, 7, 499, 2, + 500, 7, 500, 2, 501, 7, 501, 2, 502, 7, 502, 2, 503, 7, 503, 2, 504, 7, + 504, 2, 505, 7, 505, 2, 506, 7, 506, 2, 507, 7, 507, 2, 508, 7, 508, 2, + 509, 7, 509, 2, 510, 7, 510, 2, 511, 7, 511, 2, 512, 7, 512, 2, 513, 7, + 513, 2, 514, 7, 514, 2, 515, 7, 515, 2, 516, 7, 516, 2, 517, 7, 517, 2, + 518, 7, 518, 2, 519, 7, 519, 2, 520, 7, 520, 2, 521, 7, 521, 2, 522, 7, + 522, 2, 523, 7, 523, 2, 524, 7, 524, 2, 525, 7, 525, 2, 526, 7, 526, 2, + 527, 7, 527, 2, 528, 7, 528, 2, 529, 7, 529, 2, 530, 7, 530, 2, 531, 7, + 531, 2, 532, 7, 532, 2, 533, 7, 533, 2, 534, 7, 534, 2, 535, 7, 535, 2, + 536, 7, 536, 2, 537, 7, 537, 2, 538, 7, 538, 2, 539, 7, 539, 2, 540, 7, + 540, 2, 541, 7, 541, 2, 542, 7, 542, 2, 543, 7, 543, 2, 544, 7, 544, 2, + 545, 7, 545, 2, 546, 7, 546, 2, 547, 7, 547, 2, 548, 7, 548, 2, 549, 7, + 549, 2, 550, 7, 550, 2, 551, 7, 551, 2, 552, 7, 552, 2, 553, 7, 553, 2, + 554, 7, 554, 2, 555, 7, 555, 2, 556, 7, 556, 2, 557, 7, 557, 2, 558, 7, + 558, 2, 559, 7, 559, 2, 560, 7, 560, 2, 561, 7, 561, 2, 562, 7, 562, 2, + 563, 7, 563, 2, 564, 7, 564, 2, 565, 7, 565, 2, 566, 7, 566, 2, 567, 7, + 567, 2, 568, 7, 568, 2, 569, 7, 569, 2, 570, 7, 570, 2, 571, 7, 571, 2, + 572, 7, 572, 2, 573, 7, 573, 2, 574, 7, 574, 2, 575, 7, 575, 2, 576, 7, + 576, 2, 577, 7, 577, 2, 578, 7, 578, 2, 579, 7, 579, 2, 580, 7, 580, 2, + 581, 7, 581, 2, 582, 7, 582, 2, 583, 7, 583, 2, 584, 7, 584, 2, 585, 7, + 585, 2, 586, 7, 586, 2, 587, 7, 587, 2, 588, 7, 588, 2, 589, 7, 589, 2, + 590, 7, 590, 2, 591, 7, 591, 2, 592, 7, 592, 2, 593, 7, 593, 2, 594, 7, + 594, 2, 595, 7, 595, 2, 596, 7, 596, 2, 597, 7, 597, 2, 598, 7, 598, 2, + 599, 7, 599, 2, 600, 7, 600, 2, 601, 7, 601, 2, 602, 7, 602, 2, 603, 7, + 603, 2, 604, 7, 604, 2, 605, 7, 605, 2, 606, 7, 606, 2, 607, 7, 607, 2, + 608, 7, 608, 2, 609, 7, 609, 2, 610, 7, 610, 2, 611, 7, 611, 2, 612, 7, + 612, 2, 613, 7, 613, 2, 614, 7, 614, 2, 615, 7, 615, 2, 616, 7, 616, 2, + 617, 7, 617, 2, 618, 7, 618, 2, 619, 7, 619, 2, 620, 7, 620, 2, 621, 7, + 621, 2, 622, 7, 622, 2, 623, 7, 623, 2, 624, 7, 624, 1, 0, 1, 0, 1, 0, + 1, 1, 1, 1, 1, 1, 5, 1, 1257, 8, 1, 10, 1, 12, 1, 1260, 9, 1, 1, 1, 3, + 1, 1263, 8, 1, 1, 2, 3, 2, 1266, 8, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, + 2, 1, 2, 1, 2, 1, 2, 3, 2, 1277, 8, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, + 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, + 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, + 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, + 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, + 3, 1332, 8, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 5, 5, 1341, 8, + 5, 10, 5, 12, 5, 1344, 9, 5, 1, 6, 1, 6, 3, 6, 1348, 8, 6, 1, 7, 1, 7, + 1, 7, 1, 7, 1, 7, 1, 7, 5, 7, 1356, 8, 7, 10, 7, 12, 7, 1359, 9, 7, 1, + 8, 1, 8, 1, 8, 1, 9, 3, 9, 1365, 8, 9, 1, 9, 1, 9, 1, 10, 4, 10, 1370, + 8, 10, 11, 10, 12, 10, 1371, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, + 1, 11, 1, 11, 1, 11, 3, 11, 1383, 8, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, + 12, 1, 12, 3, 12, 1391, 8, 12, 1, 13, 1, 13, 1, 13, 1, 13, 3, 13, 1397, + 8, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 3, 13, 1404, 8, 13, 3, 13, 1406, + 8, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 3, 14, 1413, 8, 14, 1, 15, 1, + 15, 1, 15, 3, 15, 1418, 8, 15, 1, 16, 1, 16, 3, 16, 1422, 8, 16, 1, 16, + 3, 16, 1425, 8, 16, 1, 16, 1, 16, 3, 16, 1429, 8, 16, 1, 17, 1, 17, 1, + 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 1439, 8, 19, 1, 20, 1, 20, + 1, 20, 1, 21, 1, 21, 1, 21, 5, 21, 1447, 8, 21, 10, 21, 12, 21, 1450, 9, + 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 3, 23, 1459, 8, 23, + 1, 23, 1, 23, 1, 24, 1, 24, 3, 24, 1465, 8, 24, 1, 24, 1, 24, 1, 25, 1, + 25, 3, 25, 1471, 8, 25, 1, 26, 1, 26, 1, 26, 3, 26, 1476, 8, 26, 1, 26, + 5, 26, 1479, 8, 26, 10, 26, 12, 26, 1482, 9, 26, 1, 27, 3, 27, 1485, 8, + 27, 1, 27, 3, 27, 1488, 8, 27, 1, 27, 3, 27, 1491, 8, 27, 1, 27, 1, 27, + 1, 28, 1, 28, 3, 28, 1497, 8, 28, 1, 28, 5, 28, 1500, 8, 28, 10, 28, 12, + 28, 1503, 9, 28, 1, 29, 1, 29, 3, 29, 1507, 8, 29, 1, 30, 1, 30, 1, 30, + 3, 30, 1512, 8, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, + 30, 1, 30, 3, 30, 1523, 8, 30, 1, 31, 1, 31, 3, 31, 1527, 8, 31, 1, 32, + 1, 32, 3, 32, 1531, 8, 32, 1, 32, 1, 32, 3, 32, 1535, 8, 32, 1, 32, 1, + 32, 1, 33, 1, 33, 3, 33, 1541, 8, 33, 1, 34, 3, 34, 1544, 8, 34, 1, 34, + 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, + 34, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 1562, 8, 34, 1, 35, 1, 35, 1, 35, + 1, 35, 1, 36, 3, 36, 1569, 8, 36, 1, 36, 3, 36, 1572, 8, 36, 1, 36, 3, + 36, 1575, 8, 36, 1, 36, 3, 36, 1578, 8, 36, 1, 36, 3, 36, 1581, 8, 36, + 1, 36, 1, 36, 3, 36, 1585, 8, 36, 1, 36, 1, 36, 1, 36, 3, 36, 1590, 8, + 36, 1, 36, 1, 36, 3, 36, 1594, 8, 36, 1, 36, 1, 36, 1, 36, 3, 36, 1599, + 8, 36, 1, 37, 1, 37, 1, 37, 1, 37, 5, 37, 1605, 8, 37, 10, 37, 12, 37, + 1608, 9, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, + 39, 1, 39, 3, 39, 1620, 8, 39, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 1626, + 8, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 5, 40, 1634, 8, 40, 10, + 40, 12, 40, 1637, 9, 40, 1, 41, 1, 41, 1, 41, 3, 41, 1642, 8, 41, 1, 42, + 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 3, 44, 1652, 8, 44, 1, + 45, 1, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 1660, 8, 47, 1, 48, 1, 48, + 1, 48, 1, 49, 1, 49, 3, 49, 1667, 8, 49, 1, 50, 1, 50, 3, 50, 1671, 8, + 50, 1, 50, 3, 50, 1674, 8, 50, 1, 50, 1, 50, 3, 50, 1678, 8, 50, 1, 50, + 3, 50, 1681, 8, 50, 1, 50, 3, 50, 1684, 8, 50, 1, 51, 1, 51, 1, 51, 1, + 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, + 1, 51, 1, 51, 3, 51, 1702, 8, 51, 1, 52, 1, 52, 3, 52, 1706, 8, 52, 1, + 52, 1, 52, 1, 52, 1, 52, 5, 52, 1712, 8, 52, 10, 52, 12, 52, 1715, 9, 52, + 1, 53, 1, 53, 3, 53, 1719, 8, 53, 1, 53, 3, 53, 1722, 8, 53, 1, 53, 3, + 53, 1725, 8, 53, 1, 54, 1, 54, 1, 54, 3, 54, 1730, 8, 54, 1, 55, 1, 55, + 1, 55, 5, 55, 1735, 8, 55, 10, 55, 12, 55, 1738, 9, 55, 1, 56, 1, 56, 1, + 56, 3, 56, 1743, 8, 56, 1, 56, 3, 56, 1746, 8, 56, 1, 57, 1, 57, 1, 57, + 3, 57, 1751, 8, 57, 1, 57, 1, 57, 3, 57, 1755, 8, 57, 1, 57, 3, 57, 1758, + 8, 57, 1, 58, 1, 58, 1, 58, 3, 58, 1763, 8, 58, 1, 59, 1, 59, 1, 59, 1, + 59, 3, 59, 1769, 8, 59, 1, 59, 3, 59, 1772, 8, 59, 1, 60, 1, 60, 1, 60, + 1, 61, 1, 61, 3, 61, 1779, 8, 61, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, + 63, 1, 63, 1, 63, 5, 63, 1789, 8, 63, 10, 63, 12, 63, 1792, 9, 63, 3, 63, + 1794, 8, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 64, 3, 64, 1802, 8, + 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, + 1, 64, 3, 64, 1815, 8, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, + 64, 3, 64, 1824, 8, 64, 1, 64, 1, 64, 3, 64, 1828, 8, 64, 1, 64, 1, 64, + 1, 64, 3, 64, 1833, 8, 64, 1, 64, 1, 64, 3, 64, 1837, 8, 64, 1, 64, 1, + 64, 1, 64, 1, 64, 3, 64, 1843, 8, 64, 1, 64, 1, 64, 1, 64, 1, 64, 3, 64, + 1849, 8, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 3, 64, 1856, 8, 64, 1, + 64, 1, 64, 3, 64, 1860, 8, 64, 1, 64, 3, 64, 1863, 8, 64, 3, 64, 1865, + 8, 64, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1873, 8, 66, 1, + 66, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 3, 67, 1882, 8, 67, 1, 67, + 3, 67, 1885, 8, 67, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 3, 69, 1893, + 8, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, + 71, 1, 71, 3, 71, 1906, 8, 71, 3, 71, 1908, 8, 71, 1, 71, 1, 71, 1, 71, + 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1919, 8, 72, 3, 72, 1921, + 8, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 3, 73, 1929, 8, 73, 1, + 73, 3, 73, 1932, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, + 1940, 8, 74, 1, 74, 3, 74, 1943, 8, 74, 1, 75, 1, 75, 1, 75, 1, 75, 3, + 75, 1949, 8, 75, 1, 75, 3, 75, 1952, 8, 75, 1, 76, 1, 76, 1, 76, 1, 77, + 1, 77, 1, 77, 3, 77, 1960, 8, 77, 1, 77, 3, 77, 1963, 8, 77, 1, 78, 1, + 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 79, 3, 79, 1972, 8, 79, 1, 79, 3, 79, + 1975, 8, 79, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, + 82, 5, 82, 1986, 8, 82, 10, 82, 12, 82, 1989, 9, 82, 1, 83, 1, 83, 1, 83, + 3, 83, 1994, 8, 83, 1, 84, 1, 84, 1, 84, 1, 85, 3, 85, 2000, 8, 85, 1, + 85, 1, 85, 3, 85, 2004, 8, 85, 1, 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 88, + 1, 88, 1, 88, 1, 88, 3, 88, 2015, 8, 88, 1, 89, 1, 89, 3, 89, 2019, 8, + 89, 1, 89, 1, 89, 3, 89, 2023, 8, 89, 1, 89, 1, 89, 3, 89, 2027, 8, 89, + 1, 89, 3, 89, 2030, 8, 89, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 3, 91, 2037, + 8, 91, 1, 91, 3, 91, 2040, 8, 91, 1, 91, 3, 91, 2043, 8, 91, 1, 91, 1, + 91, 3, 91, 2047, 8, 91, 1, 91, 1, 91, 3, 91, 2051, 8, 91, 1, 91, 3, 91, + 2054, 8, 91, 1, 91, 3, 91, 2057, 8, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, + 91, 2063, 8, 91, 1, 91, 1, 91, 3, 91, 2067, 8, 91, 1, 91, 1, 91, 3, 91, + 2071, 8, 91, 1, 91, 1, 91, 3, 91, 2075, 8, 91, 1, 91, 3, 91, 2078, 8, 91, + 1, 91, 3, 91, 2081, 8, 91, 1, 91, 3, 91, 2084, 8, 91, 1, 91, 3, 91, 2087, + 8, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 2094, 8, 91, 1, 91, 1, + 91, 3, 91, 2098, 8, 91, 1, 91, 1, 91, 3, 91, 2102, 8, 91, 1, 91, 1, 91, + 3, 91, 2106, 8, 91, 1, 91, 3, 91, 2109, 8, 91, 1, 91, 3, 91, 2112, 8, 91, + 1, 91, 1, 91, 3, 91, 2116, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 2122, + 8, 92, 1, 93, 1, 93, 1, 93, 1, 93, 5, 93, 2128, 8, 93, 10, 93, 12, 93, + 2131, 9, 93, 1, 93, 1, 93, 1, 94, 1, 94, 3, 94, 2137, 8, 94, 1, 95, 1, + 95, 3, 95, 2141, 8, 95, 1, 95, 3, 95, 2144, 8, 95, 1, 95, 1, 95, 3, 95, + 2148, 8, 95, 1, 95, 1, 95, 3, 95, 2152, 8, 95, 1, 95, 3, 95, 2155, 8, 95, + 1, 95, 3, 95, 2158, 8, 95, 1, 95, 3, 95, 2161, 8, 95, 1, 95, 3, 95, 2164, + 8, 95, 1, 95, 3, 95, 2167, 8, 95, 1, 95, 3, 95, 2170, 8, 95, 1, 95, 3, + 95, 2173, 8, 95, 1, 95, 3, 95, 2176, 8, 95, 1, 95, 3, 95, 2179, 8, 95, + 1, 95, 3, 95, 2182, 8, 95, 1, 95, 3, 95, 2185, 8, 95, 1, 96, 1, 96, 1, + 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 3, 98, + 2199, 8, 98, 1, 98, 3, 98, 2202, 8, 98, 1, 99, 1, 99, 1, 99, 1, 100, 1, + 100, 3, 100, 2209, 8, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, + 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 3, 103, 2224, 8, + 103, 1, 103, 3, 103, 2227, 8, 103, 1, 103, 1, 103, 1, 103, 3, 103, 2232, + 8, 103, 1, 103, 1, 103, 3, 103, 2236, 8, 103, 1, 103, 3, 103, 2239, 8, + 103, 1, 103, 3, 103, 2242, 8, 103, 1, 103, 3, 103, 2245, 8, 103, 1, 103, + 3, 103, 2248, 8, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 3, 104, 2255, + 8, 104, 1, 105, 1, 105, 3, 105, 2259, 8, 105, 1, 105, 1, 105, 3, 105, 2263, + 8, 105, 3, 105, 2265, 8, 105, 1, 106, 1, 106, 1, 106, 1, 106, 5, 106, 2271, + 8, 106, 10, 106, 12, 106, 2274, 9, 106, 3, 106, 2276, 8, 106, 1, 106, 1, + 106, 1, 107, 1, 107, 3, 107, 2282, 8, 107, 1, 107, 1, 107, 1, 107, 3, 107, + 2287, 8, 107, 1, 107, 3, 107, 2290, 8, 107, 1, 107, 1, 107, 1, 107, 1, + 107, 3, 107, 2296, 8, 107, 1, 108, 1, 108, 3, 108, 2300, 8, 108, 1, 108, + 3, 108, 2303, 8, 108, 1, 108, 1, 108, 1, 108, 3, 108, 2308, 8, 108, 1, + 108, 1, 108, 3, 108, 2312, 8, 108, 1, 108, 1, 108, 1, 109, 1, 109, 3, 109, + 2318, 8, 109, 1, 109, 1, 109, 3, 109, 2322, 8, 109, 1, 109, 1, 109, 3, + 109, 2326, 8, 109, 1, 109, 3, 109, 2329, 8, 109, 1, 110, 1, 110, 3, 110, + 2333, 8, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 2340, 8, + 110, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 2346, 8, 110, 1, 111, 1, 111, + 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 112, 5, 112, 2356, 8, 112, 10, + 112, 12, 112, 2359, 9, 112, 1, 112, 3, 112, 2362, 8, 112, 1, 112, 1, 112, + 1, 113, 1, 113, 3, 113, 2368, 8, 113, 1, 113, 3, 113, 2371, 8, 113, 1, + 113, 3, 113, 2374, 8, 113, 1, 113, 3, 113, 2377, 8, 113, 1, 113, 3, 113, + 2380, 8, 113, 1, 114, 1, 114, 3, 114, 2384, 8, 114, 1, 115, 4, 115, 2387, + 8, 115, 11, 115, 12, 115, 2388, 1, 116, 3, 116, 2392, 8, 116, 1, 116, 1, + 116, 1, 116, 3, 116, 2397, 8, 116, 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, + 2403, 8, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, 2410, 8, + 117, 1, 118, 1, 118, 1, 118, 5, 118, 2415, 8, 118, 10, 118, 12, 118, 2418, + 9, 118, 1, 119, 1, 119, 3, 119, 2422, 8, 119, 1, 120, 1, 120, 1, 120, 1, + 121, 1, 121, 3, 121, 2429, 8, 121, 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, + 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2440, 8, 122, 1, 123, 1, 123, 1, + 123, 1, 123, 1, 123, 1, 123, 3, 123, 2448, 8, 123, 1, 124, 1, 124, 1, 124, + 1, 125, 1, 125, 3, 125, 2455, 8, 125, 1, 125, 3, 125, 2458, 8, 125, 1, + 125, 1, 125, 3, 125, 2462, 8, 125, 1, 125, 1, 125, 3, 125, 2466, 8, 125, + 1, 125, 3, 125, 2469, 8, 125, 1, 125, 3, 125, 2472, 8, 125, 1, 125, 3, + 125, 2475, 8, 125, 1, 125, 3, 125, 2478, 8, 125, 1, 126, 1, 126, 1, 126, + 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, + 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 2496, 8, 128, 1, 129, 1, 129, 1, + 129, 5, 129, 2501, 8, 129, 10, 129, 12, 129, 2504, 9, 129, 1, 130, 1, 130, + 1, 130, 1, 131, 1, 131, 3, 131, 2511, 8, 131, 1, 131, 3, 131, 2514, 8, + 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 132, 1, 132, 3, 132, 2523, + 8, 132, 1, 132, 3, 132, 2526, 8, 132, 1, 132, 1, 132, 1, 132, 3, 132, 2531, + 8, 132, 1, 132, 1, 132, 3, 132, 2535, 8, 132, 1, 132, 3, 132, 2538, 8, + 132, 1, 132, 3, 132, 2541, 8, 132, 1, 132, 3, 132, 2544, 8, 132, 1, 132, + 3, 132, 2547, 8, 132, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 1, + 135, 1, 135, 3, 135, 2557, 8, 135, 1, 135, 1, 135, 3, 135, 2561, 8, 135, + 1, 135, 1, 135, 3, 135, 2565, 8, 135, 1, 135, 3, 135, 2568, 8, 135, 1, + 135, 1, 135, 1, 135, 3, 135, 2573, 8, 135, 1, 135, 1, 135, 1, 136, 3, 136, + 2578, 8, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 137, 1, 137, 1, + 137, 3, 137, 2588, 8, 137, 1, 138, 1, 138, 3, 138, 2592, 8, 138, 1, 138, + 1, 138, 1, 138, 3, 138, 2597, 8, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, + 138, 1, 138, 3, 138, 2605, 8, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 140, + 1, 140, 1, 140, 1, 140, 5, 140, 2615, 8, 140, 10, 140, 12, 140, 2618, 9, + 140, 3, 140, 2620, 8, 140, 1, 140, 1, 140, 1, 141, 1, 141, 3, 141, 2626, + 8, 141, 1, 141, 3, 141, 2629, 8, 141, 1, 141, 3, 141, 2632, 8, 141, 1, + 141, 3, 141, 2635, 8, 141, 1, 141, 1, 141, 3, 141, 2639, 8, 141, 1, 141, + 1, 141, 1, 141, 3, 141, 2644, 8, 141, 1, 141, 3, 141, 2647, 8, 141, 1, + 141, 1, 141, 3, 141, 2651, 8, 141, 1, 141, 3, 141, 2654, 8, 141, 1, 142, + 1, 142, 3, 142, 2658, 8, 142, 1, 142, 3, 142, 2661, 8, 142, 1, 142, 1, + 142, 3, 142, 2665, 8, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 144, + 1, 144, 1, 144, 1, 145, 1, 145, 1, 145, 1, 145, 5, 145, 2679, 8, 145, 10, + 145, 12, 145, 2682, 9, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 146, 1, + 146, 5, 146, 2690, 8, 146, 10, 146, 12, 146, 2693, 9, 146, 1, 146, 1, 146, + 1, 146, 3, 146, 2698, 8, 146, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 2704, + 8, 147, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 149, + 1, 149, 1, 149, 1, 149, 5, 149, 2717, 8, 149, 10, 149, 12, 149, 2720, 9, + 149, 1, 149, 1, 149, 1, 150, 1, 150, 3, 150, 2726, 8, 150, 1, 150, 3, 150, + 2729, 8, 150, 1, 150, 3, 150, 2732, 8, 150, 1, 150, 3, 150, 2735, 8, 150, + 1, 151, 4, 151, 2738, 8, 151, 11, 151, 12, 151, 2739, 1, 152, 1, 152, 3, + 152, 2744, 8, 152, 1, 152, 3, 152, 2747, 8, 152, 1, 153, 1, 153, 1, 153, + 1, 154, 1, 154, 1, 155, 1, 155, 1, 156, 1, 156, 3, 156, 2758, 8, 156, 1, + 156, 3, 156, 2761, 8, 156, 1, 156, 1, 156, 3, 156, 2765, 8, 156, 1, 156, + 1, 156, 1, 156, 3, 156, 2770, 8, 156, 1, 156, 3, 156, 2773, 8, 156, 1, + 156, 3, 156, 2776, 8, 156, 1, 156, 1, 156, 1, 157, 1, 157, 1, 157, 1, 157, + 3, 157, 2784, 8, 157, 3, 157, 2786, 8, 157, 1, 158, 1, 158, 3, 158, 2790, + 8, 158, 1, 158, 3, 158, 2793, 8, 158, 1, 158, 1, 158, 1, 159, 1, 159, 1, + 159, 1, 159, 1, 159, 1, 159, 1, 160, 1, 160, 1, 160, 1, 161, 1, 161, 1, + 161, 5, 161, 2809, 8, 161, 10, 161, 12, 161, 2812, 9, 161, 1, 162, 1, 162, + 3, 162, 2816, 8, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, + 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 2830, 8, 163, 3, 163, + 2832, 8, 163, 1, 164, 1, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 3, + 165, 2841, 8, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 3, 166, + 2849, 8, 166, 1, 166, 1, 166, 1, 166, 1, 167, 1, 167, 3, 167, 2856, 8, + 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 168, 1, 168, 1, 168, 1, 169, 1, + 169, 3, 169, 2867, 8, 169, 1, 169, 1, 169, 1, 169, 1, 170, 1, 170, 1, 170, + 1, 170, 3, 170, 2876, 8, 170, 1, 170, 1, 170, 1, 170, 1, 171, 1, 171, 1, + 171, 1, 171, 1, 171, 1, 171, 3, 171, 2887, 8, 171, 1, 172, 1, 172, 1, 173, + 1, 173, 3, 173, 2893, 8, 173, 1, 173, 1, 173, 3, 173, 2897, 8, 173, 3, + 173, 2899, 8, 173, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 2905, 8, 174, + 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 2912, 8, 174, 1, 175, 1, + 175, 3, 175, 2916, 8, 175, 1, 175, 1, 175, 3, 175, 2920, 8, 175, 3, 175, + 2922, 8, 175, 1, 176, 1, 176, 3, 176, 2926, 8, 176, 1, 176, 1, 176, 3, + 176, 2930, 8, 176, 1, 176, 1, 176, 1, 176, 1, 177, 1, 177, 1, 177, 1, 177, + 3, 177, 2939, 8, 177, 4, 177, 2941, 8, 177, 11, 177, 12, 177, 2942, 1, + 178, 1, 178, 1, 178, 1, 178, 3, 178, 2949, 8, 178, 1, 178, 3, 178, 2952, + 8, 178, 1, 178, 3, 178, 2955, 8, 178, 1, 178, 1, 178, 1, 178, 1, 179, 1, + 179, 1, 179, 1, 179, 3, 179, 2964, 8, 179, 4, 179, 2966, 8, 179, 11, 179, + 12, 179, 2967, 1, 180, 1, 180, 3, 180, 2972, 8, 180, 1, 181, 1, 181, 1, + 181, 1, 182, 1, 182, 1, 182, 1, 182, 1, 183, 1, 183, 1, 184, 1, 184, 1, + 184, 1, 184, 5, 184, 2987, 8, 184, 10, 184, 12, 184, 2990, 9, 184, 3, 184, + 2992, 8, 184, 1, 184, 1, 184, 1, 185, 3, 185, 2997, 8, 185, 1, 185, 1, + 185, 1, 185, 1, 185, 3, 185, 3003, 8, 185, 1, 185, 1, 185, 1, 185, 1, 185, + 3, 185, 3009, 8, 185, 1, 186, 1, 186, 1, 187, 1, 187, 1, 188, 1, 188, 3, + 188, 3017, 8, 188, 1, 188, 3, 188, 3020, 8, 188, 1, 188, 3, 188, 3023, + 8, 188, 1, 188, 1, 188, 3, 188, 3027, 8, 188, 1, 188, 1, 188, 3, 188, 3031, + 8, 188, 1, 188, 3, 188, 3034, 8, 188, 1, 188, 3, 188, 3037, 8, 188, 1, + 188, 3, 188, 3040, 8, 188, 1, 188, 3, 188, 3043, 8, 188, 1, 189, 1, 189, + 1, 189, 1, 189, 1, 189, 1, 189, 3, 189, 3051, 8, 189, 1, 190, 1, 190, 1, + 190, 1, 190, 1, 191, 1, 191, 1, 192, 1, 192, 1, 192, 1, 192, 3, 192, 3063, + 8, 192, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 3, 193, + 3072, 8, 193, 1, 194, 1, 194, 3, 194, 3076, 8, 194, 1, 194, 1, 194, 3, + 194, 3080, 8, 194, 3, 194, 3082, 8, 194, 1, 195, 1, 195, 1, 195, 3, 195, + 3087, 8, 195, 1, 195, 1, 195, 3, 195, 3091, 8, 195, 3, 195, 3093, 8, 195, + 1, 196, 1, 196, 1, 196, 1, 197, 1, 197, 3, 197, 3100, 8, 197, 1, 197, 3, + 197, 3103, 8, 197, 1, 198, 1, 198, 1, 198, 1, 199, 1, 199, 1, 200, 1, 200, + 1, 200, 1, 201, 1, 201, 1, 201, 1, 202, 1, 202, 1, 202, 1, 202, 5, 202, + 3120, 8, 202, 10, 202, 12, 202, 3123, 9, 202, 3, 202, 3125, 8, 202, 1, + 202, 1, 202, 1, 203, 1, 203, 1, 203, 3, 203, 3132, 8, 203, 1, 203, 3, 203, + 3135, 8, 203, 1, 203, 3, 203, 3138, 8, 203, 1, 203, 1, 203, 3, 203, 3142, + 8, 203, 1, 203, 3, 203, 3145, 8, 203, 3, 203, 3147, 8, 203, 1, 204, 1, + 204, 1, 204, 1, 205, 1, 205, 1, 205, 1, 206, 1, 206, 1, 206, 3, 206, 3158, + 8, 206, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 5, 207, 3165, 8, 207, 10, + 207, 12, 207, 3168, 9, 207, 1, 207, 1, 207, 1, 208, 1, 208, 1, 208, 1, + 208, 3, 208, 3176, 8, 208, 1, 209, 1, 209, 1, 209, 1, 210, 1, 210, 1, 210, + 1, 210, 1, 210, 3, 210, 3186, 8, 210, 1, 211, 1, 211, 1, 212, 1, 212, 1, + 212, 1, 212, 3, 212, 3194, 8, 212, 1, 213, 1, 213, 3, 213, 3198, 8, 213, + 1, 213, 1, 213, 3, 213, 3202, 8, 213, 1, 213, 1, 213, 3, 213, 3206, 8, + 213, 1, 214, 1, 214, 3, 214, 3210, 8, 214, 1, 214, 3, 214, 3213, 8, 214, + 1, 214, 1, 214, 3, 214, 3217, 8, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, + 215, 1, 215, 1, 215, 1, 216, 1, 216, 1, 217, 1, 217, 1, 217, 1, 218, 1, + 218, 1, 218, 1, 219, 1, 219, 1, 219, 3, 219, 3237, 8, 219, 1, 220, 1, 220, + 3, 220, 3241, 8, 220, 1, 221, 1, 221, 3, 221, 3245, 8, 221, 1, 222, 1, + 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, + 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, + 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, + 222, 1, 222, 1, 222, 1, 222, 3, 222, 3279, 8, 222, 1, 223, 1, 223, 1, 223, + 5, 223, 3284, 8, 223, 10, 223, 12, 223, 3287, 9, 223, 1, 224, 1, 224, 3, + 224, 3291, 8, 224, 1, 225, 1, 225, 1, 225, 1, 225, 3, 225, 3297, 8, 225, + 3, 225, 3299, 8, 225, 1, 226, 1, 226, 1, 226, 5, 226, 3304, 8, 226, 10, + 226, 12, 226, 3307, 9, 226, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, + 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 3, 227, 3321, 8, 227, + 1, 228, 1, 228, 1, 228, 1, 228, 3, 228, 3327, 8, 228, 1, 229, 1, 229, 3, + 229, 3331, 8, 229, 1, 229, 1, 229, 3, 229, 3335, 8, 229, 1, 229, 1, 229, + 1, 229, 1, 229, 1, 229, 4, 229, 3342, 8, 229, 11, 229, 12, 229, 3343, 1, + 230, 1, 230, 3, 230, 3348, 8, 230, 1, 231, 1, 231, 1, 231, 3, 231, 3353, + 8, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 3, 231, 3361, 8, + 231, 1, 231, 3, 231, 3364, 8, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, + 1, 231, 1, 231, 1, 231, 3, 231, 3374, 8, 231, 1, 231, 1, 231, 3, 231, 3378, + 8, 231, 1, 232, 1, 232, 3, 232, 3382, 8, 232, 1, 232, 1, 232, 1, 232, 1, + 232, 1, 232, 3, 232, 3389, 8, 232, 1, 233, 1, 233, 1, 233, 3, 233, 3394, + 8, 233, 1, 234, 1, 234, 1, 234, 1, 235, 1, 235, 1, 235, 1, 236, 1, 236, + 1, 237, 1, 237, 1, 238, 1, 238, 1, 238, 3, 238, 3409, 8, 238, 1, 239, 1, + 239, 1, 239, 3, 239, 3414, 8, 239, 1, 239, 3, 239, 3417, 8, 239, 1, 239, + 3, 239, 3420, 8, 239, 1, 239, 1, 239, 1, 239, 3, 239, 3425, 8, 239, 1, + 239, 3, 239, 3428, 8, 239, 1, 239, 3, 239, 3431, 8, 239, 1, 239, 3, 239, + 3434, 8, 239, 1, 240, 1, 240, 3, 240, 3438, 8, 240, 1, 240, 1, 240, 3, + 240, 3442, 8, 240, 1, 240, 3, 240, 3445, 8, 240, 1, 240, 3, 240, 3448, + 8, 240, 1, 240, 3, 240, 3451, 8, 240, 1, 240, 3, 240, 3454, 8, 240, 1, + 240, 3, 240, 3457, 8, 240, 1, 241, 1, 241, 3, 241, 3461, 8, 241, 1, 241, + 1, 241, 3, 241, 3465, 8, 241, 1, 241, 3, 241, 3468, 8, 241, 1, 241, 1, + 241, 3, 241, 3472, 8, 241, 1, 241, 1, 241, 1, 241, 3, 241, 3477, 8, 241, + 1, 241, 3, 241, 3480, 8, 241, 1, 241, 1, 241, 3, 241, 3484, 8, 241, 1, + 241, 1, 241, 1, 241, 1, 241, 1, 241, 3, 241, 3491, 8, 241, 1, 241, 3, 241, + 3494, 8, 241, 3, 241, 3496, 8, 241, 1, 242, 1, 242, 1, 242, 3, 242, 3501, + 8, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 3, 242, 3508, 8, 242, 1, + 242, 1, 242, 1, 242, 1, 242, 1, 242, 3, 242, 3515, 8, 242, 3, 242, 3517, + 8, 242, 1, 243, 1, 243, 1, 243, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, + 3, 244, 3527, 8, 244, 1, 245, 1, 245, 1, 245, 5, 245, 3532, 8, 245, 10, + 245, 12, 245, 3535, 9, 245, 1, 246, 1, 246, 3, 246, 3539, 8, 246, 1, 247, + 1, 247, 1, 247, 1, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 249, 1, 249, + 3, 249, 3551, 8, 249, 1, 250, 1, 250, 1, 250, 1, 251, 1, 251, 3, 251, 3558, + 8, 251, 1, 251, 1, 251, 3, 251, 3562, 8, 251, 3, 251, 3564, 8, 251, 1, + 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, + 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 3, 252, 3582, 8, 252, + 1, 253, 1, 253, 1, 253, 1, 254, 1, 254, 3, 254, 3589, 8, 254, 1, 255, 1, + 255, 1, 255, 1, 255, 5, 255, 3595, 8, 255, 10, 255, 12, 255, 3598, 9, 255, + 1, 256, 1, 256, 1, 256, 1, 256, 5, 256, 3604, 8, 256, 10, 256, 12, 256, + 3607, 9, 256, 1, 256, 1, 256, 1, 257, 1, 257, 3, 257, 3613, 8, 257, 1, + 258, 1, 258, 3, 258, 3617, 8, 258, 1, 258, 3, 258, 3620, 8, 258, 1, 258, + 1, 258, 3, 258, 3624, 8, 258, 1, 259, 1, 259, 3, 259, 3628, 8, 259, 1, + 260, 1, 260, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, + 261, 1, 261, 3, 261, 3641, 8, 261, 1, 262, 1, 262, 1, 262, 3, 262, 3646, + 8, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 3, 262, 3654, 8, + 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 3, 262, 3662, 8, 262, + 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 3, 262, 3670, 8, 262, 1, + 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 3, 262, 3678, 8, 262, 1, 262, + 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, + 1, 262, 3, 262, 3691, 8, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, + 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 3, + 262, 3707, 8, 262, 1, 263, 1, 263, 3, 263, 3711, 8, 263, 1, 263, 3, 263, + 3714, 8, 263, 1, 264, 1, 264, 1, 264, 3, 264, 3719, 8, 264, 1, 265, 1, + 265, 1, 265, 1, 265, 1, 265, 3, 265, 3726, 8, 265, 1, 265, 3, 265, 3729, + 8, 265, 1, 265, 3, 265, 3732, 8, 265, 1, 265, 3, 265, 3735, 8, 265, 1, + 265, 3, 265, 3738, 8, 265, 1, 265, 3, 265, 3741, 8, 265, 1, 265, 1, 265, + 3, 265, 3745, 8, 265, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, + 266, 1, 267, 1, 267, 1, 267, 1, 267, 5, 267, 3758, 8, 267, 10, 267, 12, + 267, 3761, 9, 267, 1, 268, 1, 268, 3, 268, 3765, 8, 268, 1, 268, 3, 268, + 3768, 8, 268, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 3, 269, 3775, 8, + 269, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 3781, 8, 270, 1, 271, 1, 271, + 1, 271, 1, 271, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 5, 272, 3792, 8, + 272, 10, 272, 12, 272, 3795, 9, 272, 1, 273, 3, 273, 3798, 8, 273, 1, 273, + 1, 273, 1, 273, 1, 273, 1, 273, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, + 1, 274, 1, 274, 3, 274, 3812, 8, 274, 1, 275, 1, 275, 1, 275, 1, 275, 5, + 275, 3818, 8, 275, 10, 275, 12, 275, 3821, 9, 275, 1, 275, 3, 275, 3824, + 8, 275, 3, 275, 3826, 8, 275, 1, 275, 1, 275, 1, 276, 1, 276, 3, 276, 3832, + 8, 276, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 3840, 8, + 277, 1, 278, 1, 278, 1, 279, 1, 279, 1, 279, 1, 280, 1, 280, 1, 280, 5, + 280, 3850, 8, 280, 10, 280, 12, 280, 3853, 9, 280, 1, 281, 1, 281, 3, 281, + 3857, 8, 281, 1, 282, 1, 282, 1, 282, 5, 282, 3862, 8, 282, 10, 282, 12, + 282, 3865, 9, 282, 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, + 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, + 1, 283, 1, 283, 1, 283, 3, 283, 3886, 8, 283, 1, 284, 1, 284, 1, 284, 1, + 284, 1, 284, 1, 284, 1, 285, 1, 285, 1, 285, 5, 285, 3897, 8, 285, 10, + 285, 12, 285, 3900, 9, 285, 1, 286, 1, 286, 1, 286, 5, 286, 3905, 8, 286, + 10, 286, 12, 286, 3908, 9, 286, 1, 287, 1, 287, 3, 287, 3912, 8, 287, 1, + 288, 1, 288, 1, 288, 1, 288, 1, 289, 1, 289, 3, 289, 3920, 8, 289, 1, 290, + 1, 290, 1, 291, 1, 291, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, + 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, + 1, 292, 1, 292, 1, 292, 1, 292, 3, 292, 3945, 8, 292, 1, 293, 1, 293, 1, + 293, 5, 293, 3950, 8, 293, 10, 293, 12, 293, 3953, 9, 293, 1, 294, 1, 294, + 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, + 1, 294, 1, 294, 3, 294, 3968, 8, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, + 294, 1, 294, 3, 294, 3976, 8, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, + 3, 294, 3983, 8, 294, 1, 294, 1, 294, 1, 294, 3, 294, 3988, 8, 294, 1, + 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 3, 294, 3996, 8, 294, 1, 294, + 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 3, 294, 4006, 8, + 294, 1, 294, 1, 294, 3, 294, 4010, 8, 294, 1, 294, 3, 294, 4013, 8, 294, + 1, 294, 1, 294, 1, 294, 3, 294, 4018, 8, 294, 1, 294, 1, 294, 1, 294, 1, + 294, 3, 294, 4024, 8, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, + 1, 294, 3, 294, 4033, 8, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, + 294, 1, 294, 1, 294, 1, 294, 3, 294, 4044, 8, 294, 1, 294, 1, 294, 1, 294, + 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 3, 294, 4054, 8, 294, 1, 294, 1, + 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 3, 294, 4064, 8, 294, + 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 3, 294, 4073, 8, + 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 3, + 294, 4083, 8, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, + 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 3, 294, + 4100, 8, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, + 294, 1, 294, 3, 294, 4111, 8, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, + 1, 294, 1, 294, 1, 294, 1, 294, 3, 294, 4122, 8, 294, 1, 294, 1, 294, 1, + 294, 3, 294, 4127, 8, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, + 3, 294, 4135, 8, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 3, 294, 4142, + 8, 294, 1, 294, 1, 294, 1, 294, 1, 294, 3, 294, 4148, 8, 294, 1, 295, 1, + 295, 1, 295, 1, 295, 1, 295, 1, 296, 1, 296, 1, 296, 3, 296, 4158, 8, 296, + 1, 296, 1, 296, 1, 296, 3, 296, 4163, 8, 296, 1, 296, 3, 296, 4166, 8, + 296, 1, 296, 3, 296, 4169, 8, 296, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, + 1, 297, 1, 298, 1, 298, 1, 299, 1, 299, 1, 300, 1, 300, 1, 300, 1, 300, + 1, 301, 1, 301, 1, 301, 1, 301, 3, 301, 4189, 8, 301, 1, 302, 1, 302, 1, + 302, 3, 302, 4194, 8, 302, 1, 302, 3, 302, 4197, 8, 302, 1, 303, 4, 303, + 4200, 8, 303, 11, 303, 12, 303, 4201, 1, 303, 3, 303, 4205, 8, 303, 1, + 304, 1, 304, 1, 304, 1, 304, 3, 304, 4211, 8, 304, 1, 305, 1, 305, 1, 305, + 1, 306, 3, 306, 4217, 8, 306, 1, 306, 1, 306, 1, 307, 1, 307, 1, 308, 1, + 308, 1, 308, 1, 309, 1, 309, 3, 309, 4228, 8, 309, 1, 309, 3, 309, 4231, + 8, 309, 1, 309, 3, 309, 4234, 8, 309, 1, 310, 1, 310, 3, 310, 4238, 8, + 310, 1, 310, 1, 310, 1, 310, 1, 310, 3, 310, 4244, 8, 310, 1, 310, 1, 310, + 3, 310, 4248, 8, 310, 1, 311, 1, 311, 1, 312, 1, 312, 1, 313, 1, 313, 1, + 313, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 3, 314, 4262, 8, 314, 1, 314, + 1, 314, 1, 314, 3, 314, 4267, 8, 314, 1, 315, 1, 315, 1, 315, 3, 315, 4272, + 8, 315, 1, 315, 3, 315, 4275, 8, 315, 1, 315, 3, 315, 4278, 8, 315, 1, + 315, 3, 315, 4281, 8, 315, 1, 315, 3, 315, 4284, 8, 315, 1, 315, 1, 315, + 1, 316, 1, 316, 1, 316, 1, 316, 1, 317, 1, 317, 1, 317, 1, 317, 1, 318, + 1, 318, 1, 318, 1, 319, 1, 319, 1, 319, 1, 320, 1, 320, 1, 320, 3, 320, + 4305, 8, 320, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, + 321, 3, 321, 4315, 8, 321, 1, 322, 1, 322, 1, 322, 3, 322, 4320, 8, 322, + 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, + 1, 323, 3, 323, 4332, 8, 323, 1, 324, 1, 324, 3, 324, 4336, 8, 324, 1, + 325, 1, 325, 1, 325, 1, 325, 3, 325, 4342, 8, 325, 1, 326, 1, 326, 1, 326, + 1, 326, 1, 326, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 5, 327, 4354, 8, + 327, 10, 327, 12, 327, 4357, 9, 327, 3, 327, 4359, 8, 327, 1, 327, 1, 327, + 1, 328, 1, 328, 3, 328, 4365, 8, 328, 1, 328, 3, 328, 4368, 8, 328, 1, + 328, 1, 328, 1, 328, 3, 328, 4373, 8, 328, 1, 329, 1, 329, 3, 329, 4377, + 8, 329, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 331, 1, 331, 3, 331, + 4386, 8, 331, 1, 331, 3, 331, 4389, 8, 331, 1, 331, 3, 331, 4392, 8, 331, + 1, 332, 1, 332, 1, 333, 1, 333, 1, 333, 1, 334, 1, 334, 3, 334, 4401, 8, + 334, 1, 335, 1, 335, 1, 335, 1, 335, 1, 336, 1, 336, 1, 336, 1, 336, 3, + 336, 4411, 8, 336, 1, 336, 3, 336, 4414, 8, 336, 1, 337, 1, 337, 1, 337, + 1, 337, 5, 337, 4420, 8, 337, 10, 337, 12, 337, 4423, 9, 337, 3, 337, 4425, + 8, 337, 1, 337, 1, 337, 1, 338, 1, 338, 3, 338, 4431, 8, 338, 1, 338, 3, + 338, 4434, 8, 338, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 3, 339, 4441, + 8, 339, 1, 339, 3, 339, 4444, 8, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, + 339, 3, 339, 4451, 8, 339, 1, 339, 3, 339, 4454, 8, 339, 3, 339, 4456, + 8, 339, 1, 340, 1, 340, 1, 340, 1, 340, 3, 340, 4462, 8, 340, 1, 340, 3, + 340, 4465, 8, 340, 1, 341, 1, 341, 3, 341, 4469, 8, 341, 1, 341, 1, 341, + 3, 341, 4473, 8, 341, 3, 341, 4475, 8, 341, 1, 342, 1, 342, 1, 342, 1, + 342, 1, 343, 1, 343, 1, 343, 1, 343, 1, 344, 1, 344, 1, 344, 1, 344, 1, + 344, 1, 344, 3, 344, 4491, 8, 344, 1, 345, 1, 345, 1, 345, 1, 346, 1, 346, + 1, 346, 1, 346, 3, 346, 4500, 8, 346, 1, 347, 1, 347, 1, 347, 1, 347, 5, + 347, 4506, 8, 347, 10, 347, 12, 347, 4509, 9, 347, 1, 347, 1, 347, 1, 348, + 1, 348, 1, 348, 1, 349, 3, 349, 4517, 8, 349, 1, 349, 1, 349, 1, 350, 1, + 350, 3, 350, 4523, 8, 350, 1, 351, 1, 351, 1, 351, 1, 352, 1, 352, 3, 352, + 4530, 8, 352, 1, 353, 1, 353, 1, 354, 1, 354, 1, 354, 3, 354, 4537, 8, + 354, 1, 354, 3, 354, 4540, 8, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, + 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 3, 354, 4552, 8, 354, 1, 354, 3, + 354, 4555, 8, 354, 1, 354, 3, 354, 4558, 8, 354, 1, 354, 1, 354, 1, 354, + 1, 354, 3, 354, 4564, 8, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 3, + 354, 4571, 8, 354, 1, 354, 1, 354, 1, 354, 1, 354, 3, 354, 4577, 8, 354, + 1, 355, 1, 355, 1, 356, 1, 356, 1, 357, 1, 357, 1, 357, 1, 358, 1, 358, + 1, 359, 1, 359, 3, 359, 4590, 8, 359, 1, 360, 1, 360, 1, 361, 1, 361, 1, + 361, 4, 361, 4597, 8, 361, 11, 361, 12, 361, 4598, 1, 361, 1, 361, 1, 361, + 1, 361, 1, 361, 3, 361, 4606, 8, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, + 361, 5, 361, 4613, 8, 361, 10, 361, 12, 361, 4616, 9, 361, 1, 362, 1, 362, + 1, 362, 1, 363, 1, 363, 1, 363, 3, 363, 4624, 8, 363, 3, 363, 4626, 8, + 363, 1, 364, 3, 364, 4629, 8, 364, 1, 364, 1, 364, 3, 364, 4633, 8, 364, + 1, 364, 1, 364, 3, 364, 4637, 8, 364, 1, 364, 3, 364, 4640, 8, 364, 1, + 365, 1, 365, 1, 365, 3, 365, 4645, 8, 365, 1, 366, 1, 366, 1, 367, 1, 367, + 1, 368, 1, 368, 1, 369, 1, 369, 3, 369, 4655, 8, 369, 1, 369, 1, 369, 1, + 369, 3, 369, 4660, 8, 369, 3, 369, 4662, 8, 369, 1, 370, 1, 370, 1, 371, + 1, 371, 3, 371, 4668, 8, 371, 1, 371, 1, 371, 1, 371, 5, 371, 4673, 8, + 371, 10, 371, 12, 371, 4676, 9, 371, 1, 372, 1, 372, 1, 372, 1, 372, 3, + 372, 4682, 8, 372, 1, 373, 1, 373, 1, 374, 1, 374, 1, 374, 3, 374, 4689, + 8, 374, 1, 374, 1, 374, 1, 374, 3, 374, 4694, 8, 374, 1, 374, 1, 374, 1, + 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 3, 374, 4704, 8, 374, 1, 374, + 1, 374, 3, 374, 4708, 8, 374, 1, 375, 1, 375, 3, 375, 4712, 8, 375, 1, + 376, 1, 376, 1, 376, 3, 376, 4717, 8, 376, 1, 377, 1, 377, 1, 378, 1, 378, + 3, 378, 4723, 8, 378, 1, 378, 1, 378, 1, 378, 1, 378, 5, 378, 4729, 8, + 378, 10, 378, 12, 378, 4732, 9, 378, 1, 379, 1, 379, 3, 379, 4736, 8, 379, + 1, 379, 3, 379, 4739, 8, 379, 1, 379, 3, 379, 4742, 8, 379, 1, 380, 1, + 380, 3, 380, 4746, 8, 380, 1, 380, 3, 380, 4749, 8, 380, 1, 381, 1, 381, + 3, 381, 4753, 8, 381, 1, 381, 3, 381, 4756, 8, 381, 1, 381, 3, 381, 4759, + 8, 381, 1, 381, 3, 381, 4762, 8, 381, 1, 381, 3, 381, 4765, 8, 381, 1, + 382, 1, 382, 3, 382, 4769, 8, 382, 1, 382, 3, 382, 4772, 8, 382, 1, 382, + 3, 382, 4775, 8, 382, 1, 382, 3, 382, 4778, 8, 382, 1, 383, 1, 383, 3, + 383, 4782, 8, 383, 1, 383, 3, 383, 4785, 8, 383, 1, 383, 1, 383, 3, 383, + 4789, 8, 383, 1, 383, 3, 383, 4792, 8, 383, 1, 384, 1, 384, 1, 385, 1, + 385, 1, 385, 1, 385, 5, 385, 4800, 8, 385, 10, 385, 12, 385, 4803, 9, 385, + 1, 386, 1, 386, 1, 386, 1, 386, 1, 387, 1, 387, 1, 387, 1, 388, 1, 388, + 1, 388, 1, 389, 1, 389, 3, 389, 4817, 8, 389, 1, 390, 1, 390, 1, 390, 1, + 391, 1, 391, 3, 391, 4824, 8, 391, 1, 391, 3, 391, 4827, 8, 391, 1, 391, + 3, 391, 4830, 8, 391, 1, 391, 3, 391, 4833, 8, 391, 1, 391, 1, 391, 1, + 391, 3, 391, 4838, 8, 391, 1, 391, 3, 391, 4841, 8, 391, 1, 391, 3, 391, + 4844, 8, 391, 1, 391, 3, 391, 4847, 8, 391, 1, 391, 1, 391, 3, 391, 4851, + 8, 391, 1, 392, 1, 392, 1, 392, 1, 392, 3, 392, 4857, 8, 392, 1, 393, 1, + 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 3, 393, 4866, 8, 393, 1, 394, + 1, 394, 1, 394, 1, 395, 1, 395, 5, 395, 4873, 8, 395, 10, 395, 12, 395, + 4876, 9, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 3, 395, 4884, + 8, 395, 1, 396, 1, 396, 1, 396, 3, 396, 4889, 8, 396, 1, 396, 3, 396, 4892, + 8, 396, 1, 396, 3, 396, 4895, 8, 396, 1, 396, 1, 396, 3, 396, 4899, 8, + 396, 1, 396, 1, 396, 3, 396, 4903, 8, 396, 3, 396, 4905, 8, 396, 1, 397, + 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 3, 397, 4915, 8, + 397, 1, 397, 1, 397, 1, 397, 1, 397, 5, 397, 4921, 8, 397, 10, 397, 12, + 397, 4924, 9, 397, 1, 398, 1, 398, 1, 398, 3, 398, 4929, 8, 398, 1, 398, + 3, 398, 4932, 8, 398, 1, 398, 1, 398, 1, 398, 3, 398, 4937, 8, 398, 1, + 398, 3, 398, 4940, 8, 398, 3, 398, 4942, 8, 398, 1, 399, 1, 399, 1, 399, + 1, 399, 1, 399, 1, 399, 1, 399, 3, 399, 4951, 8, 399, 1, 399, 1, 399, 1, + 399, 1, 399, 3, 399, 4957, 8, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, + 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, + 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 3, 399, 4978, 8, 399, 1, 399, 1, + 399, 3, 399, 4982, 8, 399, 1, 399, 1, 399, 1, 399, 3, 399, 4987, 8, 399, + 1, 400, 3, 400, 4990, 8, 400, 1, 400, 1, 400, 1, 401, 1, 401, 1, 401, 1, + 401, 1, 401, 1, 401, 1, 401, 1, 402, 1, 402, 1, 402, 1, 402, 3, 402, 5005, + 8, 402, 1, 402, 1, 402, 1, 402, 1, 402, 3, 402, 5011, 8, 402, 1, 402, 1, + 402, 1, 402, 1, 402, 1, 402, 3, 402, 5018, 8, 402, 3, 402, 5020, 8, 402, + 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 404, 1, 404, 3, 404, 5029, 8, + 404, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 3, 405, 5037, 8, 405, + 1, 405, 1, 405, 1, 406, 1, 406, 1, 406, 3, 406, 5044, 8, 406, 1, 407, 1, + 407, 3, 407, 5048, 8, 407, 1, 408, 1, 408, 1, 409, 1, 409, 1, 409, 1, 409, + 1, 409, 5, 409, 5057, 8, 409, 10, 409, 12, 409, 5060, 9, 409, 1, 410, 1, + 410, 1, 410, 3, 410, 5065, 8, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, + 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 3, 410, 5078, 8, 410, 1, + 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 5, 411, 5086, 8, 411, 10, + 411, 12, 411, 5089, 9, 411, 1, 412, 1, 412, 1, 412, 1, 412, 1, 412, 5, + 412, 5096, 8, 412, 10, 412, 12, 412, 5099, 9, 412, 1, 413, 1, 413, 1, 413, + 1, 413, 1, 413, 3, 413, 5106, 8, 413, 1, 414, 1, 414, 1, 414, 5, 414, 5111, + 8, 414, 10, 414, 12, 414, 5114, 9, 414, 1, 415, 1, 415, 1, 415, 1, 415, + 1, 416, 1, 416, 3, 416, 5122, 8, 416, 1, 417, 1, 417, 5, 417, 5126, 8, + 417, 10, 417, 12, 417, 5129, 9, 417, 1, 418, 3, 418, 5132, 8, 418, 1, 418, + 3, 418, 5135, 8, 418, 1, 418, 3, 418, 5138, 8, 418, 1, 418, 1, 418, 3, + 418, 5142, 8, 418, 1, 418, 1, 418, 3, 418, 5146, 8, 418, 1, 419, 4, 419, + 5149, 8, 419, 11, 419, 12, 419, 5150, 1, 420, 1, 420, 3, 420, 5155, 8, + 420, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 5, 421, 5162, 8, 421, 10, + 421, 12, 421, 5165, 9, 421, 1, 421, 1, 421, 1, 422, 1, 422, 1, 423, 1, + 423, 3, 423, 5173, 8, 423, 1, 423, 3, 423, 5176, 8, 423, 1, 423, 3, 423, + 5179, 8, 423, 1, 423, 3, 423, 5182, 8, 423, 1, 424, 1, 424, 1, 424, 1, + 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 3, 424, 5195, + 8, 424, 1, 425, 1, 425, 1, 425, 3, 425, 5200, 8, 425, 1, 426, 1, 426, 1, + 426, 1, 426, 1, 426, 1, 426, 1, 426, 3, 426, 5209, 8, 426, 1, 426, 1, 426, + 1, 426, 1, 426, 3, 426, 5215, 8, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, + 426, 1, 426, 1, 426, 1, 426, 3, 426, 5225, 8, 426, 1, 426, 1, 426, 1, 426, + 3, 426, 5230, 8, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 3, + 426, 5238, 8, 426, 1, 426, 1, 426, 3, 426, 5242, 8, 426, 1, 426, 1, 426, + 1, 426, 3, 426, 5247, 8, 426, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, + 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, + 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 3, 427, 5269, 8, 427, 1, 428, + 1, 428, 3, 428, 5273, 8, 428, 1, 429, 1, 429, 3, 429, 5277, 8, 429, 1, + 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, 5, 430, 5285, 8, 430, 10, + 430, 12, 430, 5288, 9, 430, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, + 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 3, + 431, 5304, 8, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, + 1, 431, 1, 431, 1, 431, 1, 431, 5, 431, 5317, 8, 431, 10, 431, 12, 431, + 5320, 9, 431, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, + 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 5, 432, 5336, 8, 432, + 10, 432, 12, 432, 5339, 9, 432, 1, 433, 1, 433, 3, 433, 5343, 8, 433, 1, + 434, 1, 434, 1, 434, 1, 434, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, + 435, 3, 435, 5355, 8, 435, 1, 436, 1, 436, 3, 436, 5359, 8, 436, 1, 436, + 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 3, 436, 5367, 8, 436, 1, 437, 1, + 437, 1, 437, 1, 437, 1, 437, 5, 437, 5374, 8, 437, 10, 437, 12, 437, 5377, + 9, 437, 1, 438, 1, 438, 1, 438, 1, 439, 1, 439, 3, 439, 5384, 8, 439, 1, + 440, 1, 440, 1, 440, 1, 440, 5, 440, 5390, 8, 440, 10, 440, 12, 440, 5393, + 9, 440, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, + 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, + 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, + 1, 441, 1, 441, 1, 441, 1, 441, 3, 441, 5425, 8, 441, 1, 442, 1, 442, 1, + 442, 1, 443, 1, 443, 3, 443, 5432, 8, 443, 1, 444, 1, 444, 1, 444, 1, 444, + 1, 444, 1, 445, 1, 445, 1, 445, 5, 445, 5442, 8, 445, 10, 445, 12, 445, + 5445, 9, 445, 1, 446, 1, 446, 1, 447, 1, 447, 1, 447, 1, 447, 3, 447, 5453, + 8, 447, 1, 448, 1, 448, 1, 448, 1, 449, 1, 449, 1, 449, 1, 450, 1, 450, + 3, 450, 5463, 8, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, + 450, 1, 450, 1, 451, 1, 451, 1, 451, 1, 452, 1, 452, 1, 452, 1, 452, 1, + 452, 1, 452, 1, 452, 5, 452, 5483, 8, 452, 10, 452, 12, 452, 5486, 9, 452, + 1, 453, 1, 453, 3, 453, 5490, 8, 453, 1, 454, 3, 454, 5493, 8, 454, 1, + 454, 1, 454, 3, 454, 5497, 8, 454, 1, 454, 3, 454, 5500, 8, 454, 1, 455, + 1, 455, 1, 455, 1, 455, 1, 455, 3, 455, 5507, 8, 455, 1, 456, 1, 456, 1, + 456, 5, 456, 5512, 8, 456, 10, 456, 12, 456, 5515, 9, 456, 1, 457, 1, 457, + 1, 457, 1, 457, 3, 457, 5521, 8, 457, 1, 458, 1, 458, 1, 458, 1, 458, 1, + 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 459, 1, 459, 1, + 459, 5, 459, 5537, 8, 459, 10, 459, 12, 459, 5540, 9, 459, 1, 460, 1, 460, + 3, 460, 5544, 8, 460, 1, 461, 1, 461, 1, 461, 5, 461, 5549, 8, 461, 10, + 461, 12, 461, 5552, 9, 461, 1, 462, 1, 462, 3, 462, 5556, 8, 462, 1, 463, + 1, 463, 1, 463, 3, 463, 5561, 8, 463, 1, 464, 1, 464, 1, 464, 3, 464, 5566, + 8, 464, 1, 464, 1, 464, 1, 464, 3, 464, 5571, 8, 464, 1, 464, 1, 464, 3, + 464, 5575, 8, 464, 3, 464, 5577, 8, 464, 1, 465, 1, 465, 1, 466, 1, 466, + 1, 466, 1, 467, 1, 467, 1, 467, 5, 467, 5587, 8, 467, 10, 467, 12, 467, + 5590, 9, 467, 1, 467, 3, 467, 5593, 8, 467, 1, 468, 1, 468, 1, 468, 3, + 468, 5598, 8, 468, 1, 469, 1, 469, 3, 469, 5602, 8, 469, 1, 470, 1, 470, + 1, 470, 1, 470, 1, 470, 3, 470, 5609, 8, 470, 1, 471, 1, 471, 1, 471, 1, + 471, 3, 471, 5615, 8, 471, 1, 472, 1, 472, 3, 472, 5619, 8, 472, 1, 472, + 3, 472, 5622, 8, 472, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 5, 473, 5629, + 8, 473, 10, 473, 12, 473, 5632, 9, 473, 1, 473, 1, 473, 1, 474, 1, 474, + 1, 474, 1, 474, 1, 474, 5, 474, 5641, 8, 474, 10, 474, 12, 474, 5644, 9, + 474, 1, 474, 1, 474, 1, 475, 1, 475, 1, 475, 1, 475, 1, 476, 1, 476, 1, + 476, 3, 476, 5655, 8, 476, 1, 476, 1, 476, 1, 476, 5, 476, 5660, 8, 476, + 10, 476, 12, 476, 5663, 9, 476, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, + 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, + 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, + 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, + 1, 477, 1, 477, 1, 477, 1, 477, 3, 477, 5701, 8, 477, 1, 477, 1, 477, 1, + 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, + 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, + 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, + 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, + 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, + 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, + 477, 1, 477, 1, 477, 1, 477, 3, 477, 5763, 8, 477, 1, 477, 1, 477, 1, 477, + 1, 477, 1, 477, 1, 477, 3, 477, 5771, 8, 477, 1, 477, 1, 477, 1, 477, 1, + 477, 1, 477, 3, 477, 5778, 8, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, + 1, 477, 3, 477, 5786, 8, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, + 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, + 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 5, 477, 5808, 8, 477, 10, + 477, 12, 477, 5811, 9, 477, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, + 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, + 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, + 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, + 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, + 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 3, + 478, 5863, 8, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 3, 478, + 5871, 8, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, + 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 3, 478, 5886, 8, 478, 1, 478, + 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 3, 478, 5894, 8, 478, 1, 478, 1, + 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, + 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, + 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, + 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, + 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, + 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, + 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, + 478, 1, 478, 3, 478, 5962, 8, 478, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, + 1, 479, 1, 479, 1, 479, 3, 479, 5972, 8, 479, 1, 480, 1, 480, 1, 481, 1, + 481, 1, 482, 1, 482, 1, 483, 1, 483, 1, 484, 1, 484, 1, 485, 1, 485, 3, + 485, 5986, 8, 485, 1, 486, 3, 486, 5989, 8, 486, 1, 486, 1, 486, 1, 487, + 3, 487, 5994, 8, 487, 1, 487, 1, 487, 1, 488, 1, 488, 3, 488, 6000, 8, + 488, 1, 488, 1, 488, 1, 488, 1, 489, 1, 489, 1, 489, 1, 489, 1, 490, 1, + 490, 1, 490, 1, 490, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 3, 491, 6018, + 8, 491, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 5, 492, 6025, 8, 492, 10, + 492, 12, 492, 6028, 9, 492, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, + 493, 5, 493, 6036, 8, 493, 10, 493, 12, 493, 6039, 9, 493, 1, 494, 1, 494, + 1, 495, 1, 495, 1, 495, 3, 495, 6046, 8, 495, 1, 496, 1, 496, 1, 496, 1, + 496, 3, 496, 6052, 8, 496, 1, 496, 3, 496, 6055, 8, 496, 1, 497, 1, 497, + 1, 497, 1, 497, 1, 497, 1, 497, 1, 497, 1, 497, 1, 497, 3, 497, 6066, 8, + 497, 1, 498, 1, 498, 1, 498, 1, 498, 5, 498, 6072, 8, 498, 10, 498, 12, + 498, 6075, 9, 498, 1, 499, 1, 499, 3, 499, 6079, 8, 499, 1, 500, 1, 500, + 1, 500, 1, 500, 1, 500, 1, 500, 5, 500, 6087, 8, 500, 10, 500, 12, 500, + 6090, 9, 500, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 3, 501, 6097, 8, + 501, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 3, 502, 6104, 8, 502, 1, 503, + 1, 503, 1, 503, 3, 503, 6109, 8, 503, 1, 503, 1, 503, 1, 503, 1, 503, 1, + 503, 1, 503, 3, 503, 6117, 8, 503, 1, 504, 3, 504, 6120, 8, 504, 1, 504, + 3, 504, 6123, 8, 504, 1, 504, 3, 504, 6126, 8, 504, 1, 504, 1, 504, 1, + 504, 3, 504, 6131, 8, 504, 1, 504, 1, 504, 5, 504, 6135, 8, 504, 10, 504, + 12, 504, 6138, 9, 504, 1, 504, 3, 504, 6141, 8, 504, 1, 504, 3, 504, 6144, + 8, 504, 1, 504, 3, 504, 6147, 8, 504, 1, 504, 3, 504, 6150, 8, 504, 1, + 504, 3, 504, 6153, 8, 504, 1, 504, 3, 504, 6156, 8, 504, 1, 504, 3, 504, + 6159, 8, 504, 1, 504, 3, 504, 6162, 8, 504, 1, 504, 3, 504, 6165, 8, 504, + 1, 504, 3, 504, 6168, 8, 504, 1, 505, 1, 505, 1, 505, 1, 506, 1, 506, 1, + 506, 3, 506, 6176, 8, 506, 1, 506, 3, 506, 6179, 8, 506, 1, 506, 3, 506, + 6182, 8, 506, 1, 506, 3, 506, 6185, 8, 506, 1, 506, 3, 506, 6188, 8, 506, + 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, + 3, 507, 6199, 8, 507, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, + 508, 3, 508, 6208, 8, 508, 1, 509, 1, 509, 1, 510, 1, 510, 1, 511, 1, 511, + 1, 512, 1, 512, 3, 512, 6218, 8, 512, 1, 512, 1, 512, 1, 512, 1, 512, 5, + 512, 6224, 8, 512, 10, 512, 12, 512, 6227, 9, 512, 1, 513, 1, 513, 1, 513, + 1, 513, 1, 514, 1, 514, 1, 514, 1, 514, 1, 515, 1, 515, 1, 515, 1, 515, + 1, 515, 1, 516, 1, 516, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 3, 517, + 6249, 8, 517, 1, 518, 1, 518, 1, 518, 1, 518, 5, 518, 6255, 8, 518, 10, + 518, 12, 518, 6258, 9, 518, 1, 519, 1, 519, 1, 519, 1, 519, 1, 520, 1, + 520, 3, 520, 6266, 8, 520, 1, 521, 1, 521, 1, 522, 1, 522, 1, 522, 1, 522, + 3, 522, 6274, 8, 522, 1, 523, 1, 523, 3, 523, 6278, 8, 523, 1, 523, 1, + 523, 1, 523, 1, 523, 1, 523, 3, 523, 6285, 8, 523, 1, 524, 1, 524, 1, 524, + 1, 525, 1, 525, 1, 525, 1, 525, 1, 525, 1, 525, 1, 525, 1, 525, 3, 525, + 6298, 8, 525, 1, 526, 1, 526, 1, 526, 1, 526, 1, 527, 1, 527, 1, 527, 3, + 527, 6307, 8, 527, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, + 3, 528, 6316, 8, 528, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, + 529, 1, 529, 3, 529, 6326, 8, 529, 1, 530, 1, 530, 1, 530, 1, 530, 5, 530, + 6332, 8, 530, 10, 530, 12, 530, 6335, 9, 530, 1, 531, 1, 531, 3, 531, 6339, + 8, 531, 1, 531, 3, 531, 6342, 8, 531, 1, 531, 1, 531, 1, 532, 1, 532, 1, + 532, 1, 533, 1, 533, 1, 533, 3, 533, 6352, 8, 533, 1, 534, 1, 534, 1, 534, + 1, 535, 1, 535, 1, 535, 1, 535, 3, 535, 6361, 8, 535, 1, 535, 1, 535, 1, + 535, 1, 535, 5, 535, 6367, 8, 535, 10, 535, 12, 535, 6370, 9, 535, 1, 536, + 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, + 3, 536, 6382, 8, 536, 1, 537, 1, 537, 3, 537, 6386, 8, 537, 1, 538, 1, + 538, 1, 539, 1, 539, 1, 539, 1, 539, 3, 539, 6394, 8, 539, 1, 539, 3, 539, + 6397, 8, 539, 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, 1, + 539, 1, 539, 3, 539, 6408, 8, 539, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, + 1, 540, 5, 540, 6416, 8, 540, 10, 540, 12, 540, 6419, 9, 540, 1, 541, 1, + 541, 1, 541, 1, 541, 1, 541, 1, 541, 1, 541, 1, 541, 1, 541, 3, 541, 6430, + 8, 541, 1, 542, 1, 542, 1, 542, 1, 542, 5, 542, 6436, 8, 542, 10, 542, + 12, 542, 6439, 9, 542, 1, 543, 1, 543, 1, 543, 1, 543, 1, 543, 5, 543, + 6446, 8, 543, 10, 543, 12, 543, 6449, 9, 543, 1, 544, 1, 544, 1, 544, 1, + 545, 1, 545, 3, 545, 6456, 8, 545, 1, 546, 1, 546, 3, 546, 6460, 8, 546, + 1, 547, 1, 547, 1, 548, 1, 548, 1, 548, 1, 548, 3, 548, 6468, 8, 548, 1, + 549, 1, 549, 1, 550, 1, 550, 1, 550, 1, 551, 1, 551, 1, 551, 1, 551, 1, + 551, 1, 551, 1, 551, 5, 551, 6482, 8, 551, 10, 551, 12, 551, 6485, 9, 551, + 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 3, 552, + 6495, 8, 552, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, + 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 5, 553, 6511, 8, 553, + 10, 553, 12, 553, 6514, 9, 553, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, + 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, + 5, 554, 6530, 8, 554, 10, 554, 12, 554, 6533, 9, 554, 1, 555, 1, 555, 1, + 555, 1, 555, 1, 555, 1, 555, 1, 555, 1, 556, 1, 556, 1, 556, 5, 556, 6545, + 8, 556, 10, 556, 12, 556, 6548, 9, 556, 1, 557, 1, 557, 1, 557, 1, 557, + 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, + 1, 558, 3, 558, 6564, 8, 558, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, + 559, 1, 560, 1, 560, 1, 560, 3, 560, 6575, 8, 560, 1, 561, 1, 561, 1, 561, + 1, 561, 1, 561, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 3, 562, + 6588, 8, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, + 562, 1, 562, 1, 562, 1, 562, 1, 562, 3, 562, 6602, 8, 562, 1, 562, 1, 562, + 1, 562, 1, 562, 1, 562, 1, 562, 3, 562, 6610, 8, 562, 1, 563, 1, 563, 1, + 563, 1, 563, 1, 563, 1, 563, 1, 563, 1, 563, 3, 563, 6620, 8, 563, 1, 564, + 1, 564, 3, 564, 6624, 8, 564, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, + 565, 1, 565, 4, 565, 6633, 8, 565, 11, 565, 12, 565, 6634, 1, 566, 1, 566, + 1, 566, 1, 566, 1, 566, 1, 566, 4, 566, 6643, 8, 566, 11, 566, 12, 566, + 6644, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 3, 567, 6652, 8, 567, 1, + 568, 1, 568, 1, 568, 1, 568, 1, 569, 1, 569, 1, 569, 1, 569, 1, 569, 1, + 569, 1, 569, 1, 569, 3, 569, 6666, 8, 569, 1, 570, 1, 570, 1, 571, 1, 571, + 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 3, 571, 6677, 8, 571, 1, 571, 1, + 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 5, 571, 6687, 8, 571, + 10, 571, 12, 571, 6690, 9, 571, 1, 572, 1, 572, 1, 572, 1, 573, 1, 573, + 1, 574, 1, 574, 1, 574, 3, 574, 6700, 8, 574, 1, 575, 1, 575, 1, 575, 1, + 575, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 3, 576, 6712, 8, 576, + 1, 577, 1, 577, 1, 577, 1, 577, 5, 577, 6718, 8, 577, 10, 577, 12, 577, + 6721, 9, 577, 1, 578, 1, 578, 1, 578, 1, 578, 1, 579, 1, 579, 1, 579, 1, + 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 3, 579, 6738, + 8, 579, 1, 580, 1, 580, 1, 580, 1, 580, 1, 580, 1, 580, 3, 580, 6746, 8, + 580, 1, 581, 1, 581, 1, 581, 1, 581, 5, 581, 6752, 8, 581, 10, 581, 12, + 581, 6755, 9, 581, 1, 582, 1, 582, 1, 582, 1, 582, 1, 582, 1, 582, 3, 582, + 6763, 8, 582, 1, 583, 1, 583, 1, 583, 1, 584, 1, 584, 1, 584, 1, 584, 1, + 584, 1, 585, 1, 585, 3, 585, 6775, 8, 585, 1, 585, 3, 585, 6778, 8, 585, + 1, 586, 1, 586, 1, 586, 1, 587, 1, 587, 1, 587, 3, 587, 6786, 8, 587, 1, + 588, 1, 588, 1, 588, 1, 589, 1, 589, 3, 589, 6793, 8, 589, 1, 590, 1, 590, + 1, 590, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, + 3, 591, 6806, 8, 591, 1, 592, 1, 592, 1, 592, 1, 592, 5, 592, 6812, 8, + 592, 10, 592, 12, 592, 6815, 9, 592, 1, 593, 1, 593, 1, 593, 1, 593, 1, + 593, 1, 593, 3, 593, 6823, 8, 593, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, + 1, 594, 3, 594, 6831, 8, 594, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, + 595, 1, 595, 1, 596, 1, 596, 1, 596, 1, 596, 1, 596, 1, 596, 1, 596, 1, + 596, 1, 596, 1, 596, 1, 596, 1, 596, 1, 596, 1, 596, 1, 596, 1, 596, 1, + 596, 1, 596, 1, 596, 1, 596, 1, 596, 3, 596, 6861, 8, 596, 1, 597, 1, 597, + 1, 597, 1, 597, 1, 597, 1, 597, 5, 597, 6869, 8, 597, 10, 597, 12, 597, + 6872, 9, 597, 1, 598, 1, 598, 3, 598, 6876, 8, 598, 1, 599, 1, 599, 1, + 599, 5, 599, 6881, 8, 599, 10, 599, 12, 599, 6884, 9, 599, 1, 600, 1, 600, + 3, 600, 6888, 8, 600, 1, 601, 1, 601, 3, 601, 6892, 8, 601, 1, 602, 1, + 602, 1, 603, 1, 603, 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 1, + 604, 3, 604, 6905, 8, 604, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 5, 605, + 6912, 8, 605, 10, 605, 12, 605, 6915, 9, 605, 1, 606, 1, 606, 1, 606, 1, + 606, 3, 606, 6921, 8, 606, 1, 607, 1, 607, 1, 607, 1, 607, 1, 607, 1, 608, + 1, 608, 1, 609, 1, 609, 1, 610, 1, 610, 1, 610, 1, 611, 1, 611, 1, 612, + 1, 612, 1, 613, 1, 613, 1, 613, 1, 614, 1, 614, 1, 614, 1, 615, 1, 615, + 1, 616, 1, 616, 1, 616, 1, 617, 1, 617, 1, 618, 1, 618, 1, 619, 1, 619, + 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, + 5, 619, 6965, 8, 619, 10, 619, 12, 619, 6968, 9, 619, 1, 620, 1, 620, 1, + 621, 1, 621, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, + 622, 1, 622, 1, 622, 1, 622, 5, 622, 6985, 8, 622, 10, 622, 12, 622, 6988, + 9, 622, 1, 623, 1, 623, 1, 624, 1, 624, 1, 624, 0, 16, 80, 722, 794, 822, + 824, 860, 862, 864, 904, 952, 954, 1106, 1108, 1142, 1238, 1244, 625, 0, + 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, + 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, + 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, + 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, + 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, + 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, + 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, + 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, + 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, + 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, + 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, + 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, + 380, 382, 384, 386, 388, 390, 392, 394, 396, 398, 400, 402, 404, 406, 408, + 410, 412, 414, 416, 418, 420, 422, 424, 426, 428, 430, 432, 434, 436, 438, + 440, 442, 444, 446, 448, 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, + 470, 472, 474, 476, 478, 480, 482, 484, 486, 488, 490, 492, 494, 496, 498, + 500, 502, 504, 506, 508, 510, 512, 514, 516, 518, 520, 522, 524, 526, 528, + 530, 532, 534, 536, 538, 540, 542, 544, 546, 548, 550, 552, 554, 556, 558, + 560, 562, 564, 566, 568, 570, 572, 574, 576, 578, 580, 582, 584, 586, 588, + 590, 592, 594, 596, 598, 600, 602, 604, 606, 608, 610, 612, 614, 616, 618, + 620, 622, 624, 626, 628, 630, 632, 634, 636, 638, 640, 642, 644, 646, 648, + 650, 652, 654, 656, 658, 660, 662, 664, 666, 668, 670, 672, 674, 676, 678, + 680, 682, 684, 686, 688, 690, 692, 694, 696, 698, 700, 702, 704, 706, 708, + 710, 712, 714, 716, 718, 720, 722, 724, 726, 728, 730, 732, 734, 736, 738, + 740, 742, 744, 746, 748, 750, 752, 754, 756, 758, 760, 762, 764, 766, 768, + 770, 772, 774, 776, 778, 780, 782, 784, 786, 788, 790, 792, 794, 796, 798, + 800, 802, 804, 806, 808, 810, 812, 814, 816, 818, 820, 822, 824, 826, 828, + 830, 832, 834, 836, 838, 840, 842, 844, 846, 848, 850, 852, 854, 856, 858, + 860, 862, 864, 866, 868, 870, 872, 874, 876, 878, 880, 882, 884, 886, 888, + 890, 892, 894, 896, 898, 900, 902, 904, 906, 908, 910, 912, 914, 916, 918, + 920, 922, 924, 926, 928, 930, 932, 934, 936, 938, 940, 942, 944, 946, 948, + 950, 952, 954, 956, 958, 960, 962, 964, 966, 968, 970, 972, 974, 976, 978, + 980, 982, 984, 986, 988, 990, 992, 994, 996, 998, 1000, 1002, 1004, 1006, + 1008, 1010, 1012, 1014, 1016, 1018, 1020, 1022, 1024, 1026, 1028, 1030, + 1032, 1034, 1036, 1038, 1040, 1042, 1044, 1046, 1048, 1050, 1052, 1054, + 1056, 1058, 1060, 1062, 1064, 1066, 1068, 1070, 1072, 1074, 1076, 1078, + 1080, 1082, 1084, 1086, 1088, 1090, 1092, 1094, 1096, 1098, 1100, 1102, + 1104, 1106, 1108, 1110, 1112, 1114, 1116, 1118, 1120, 1122, 1124, 1126, + 1128, 1130, 1132, 1134, 1136, 1138, 1140, 1142, 1144, 1146, 1148, 1150, + 1152, 1154, 1156, 1158, 1160, 1162, 1164, 1166, 1168, 1170, 1172, 1174, + 1176, 1178, 1180, 1182, 1184, 1186, 1188, 1190, 1192, 1194, 1196, 1198, + 1200, 1202, 1204, 1206, 1208, 1210, 1212, 1214, 1216, 1218, 1220, 1222, + 1224, 1226, 1228, 1230, 1232, 1234, 1236, 1238, 1240, 1242, 1244, 1246, + 1248, 0, 39, 1, 0, 357, 358, 2, 0, 121, 121, 359, 361, 2, 0, 57, 57, 333, + 333, 2, 0, 58, 58, 338, 338, 2, 0, 216, 216, 311, 311, 2, 0, 137, 137, + 243, 243, 2, 0, 64, 64, 159, 159, 2, 0, 253, 253, 283, 283, 2, 0, 155, + 155, 192, 192, 2, 0, 17, 17, 22, 22, 3, 0, 73, 73, 189, 189, 218, 218, + 3, 0, 226, 226, 231, 231, 271, 272, 2, 0, 220, 220, 338, 338, 2, 0, 230, + 230, 364, 364, 2, 0, 241, 241, 364, 364, 3, 0, 95, 95, 307, 307, 329, 329, + 5, 0, 68, 68, 76, 76, 78, 78, 86, 86, 100, 100, 2, 0, 71, 71, 95, 95, 2, + 0, 57, 57, 66, 66, 3, 0, 68, 68, 76, 76, 100, 100, 2, 0, 88, 88, 315, 315, + 2, 0, 310, 310, 328, 328, 2, 0, 10, 11, 14, 14, 1, 0, 1, 7, 1, 0, 8, 9, + 1, 0, 10, 11, 1, 0, 12, 13, 2, 0, 57, 57, 333, 334, 1, 0, 320, 321, 2, + 0, 119, 119, 315, 315, 2, 0, 1, 1, 38, 39, 1, 0, 310, 312, 2, 0, 59, 59, + 64, 64, 4, 0, 77, 77, 91, 91, 119, 119, 303, 305, 14, 0, 74, 74, 83, 83, + 85, 85, 88, 89, 93, 94, 97, 98, 103, 103, 107, 110, 114, 118, 122, 256, + 258, 294, 340, 340, 345, 355, 357, 363, 1, 0, 115, 118, 1, 0, 109, 110, + 1, 0, 107, 108, 1, 0, 105, 106, 7574, 0, 1250, 1, 0, 0, 0, 2, 1253, 1, + 0, 0, 0, 4, 1276, 1, 0, 0, 0, 6, 1331, 1, 0, 0, 0, 8, 1333, 1, 0, 0, 0, + 10, 1337, 1, 0, 0, 0, 12, 1347, 1, 0, 0, 0, 14, 1349, 1, 0, 0, 0, 16, 1360, + 1, 0, 0, 0, 18, 1364, 1, 0, 0, 0, 20, 1369, 1, 0, 0, 0, 22, 1382, 1, 0, + 0, 0, 24, 1384, 1, 0, 0, 0, 26, 1405, 1, 0, 0, 0, 28, 1407, 1, 0, 0, 0, + 30, 1414, 1, 0, 0, 0, 32, 1419, 1, 0, 0, 0, 34, 1430, 1, 0, 0, 0, 36, 1432, + 1, 0, 0, 0, 38, 1438, 1, 0, 0, 0, 40, 1440, 1, 0, 0, 0, 42, 1443, 1, 0, + 0, 0, 44, 1451, 1, 0, 0, 0, 46, 1455, 1, 0, 0, 0, 48, 1462, 1, 0, 0, 0, + 50, 1468, 1, 0, 0, 0, 52, 1472, 1, 0, 0, 0, 54, 1484, 1, 0, 0, 0, 56, 1494, + 1, 0, 0, 0, 58, 1506, 1, 0, 0, 0, 60, 1522, 1, 0, 0, 0, 62, 1526, 1, 0, + 0, 0, 64, 1528, 1, 0, 0, 0, 66, 1540, 1, 0, 0, 0, 68, 1561, 1, 0, 0, 0, + 70, 1563, 1, 0, 0, 0, 72, 1598, 1, 0, 0, 0, 74, 1600, 1, 0, 0, 0, 76, 1611, + 1, 0, 0, 0, 78, 1619, 1, 0, 0, 0, 80, 1625, 1, 0, 0, 0, 82, 1641, 1, 0, + 0, 0, 84, 1643, 1, 0, 0, 0, 86, 1647, 1, 0, 0, 0, 88, 1649, 1, 0, 0, 0, + 90, 1653, 1, 0, 0, 0, 92, 1655, 1, 0, 0, 0, 94, 1657, 1, 0, 0, 0, 96, 1661, + 1, 0, 0, 0, 98, 1666, 1, 0, 0, 0, 100, 1668, 1, 0, 0, 0, 102, 1701, 1, + 0, 0, 0, 104, 1703, 1, 0, 0, 0, 106, 1716, 1, 0, 0, 0, 108, 1729, 1, 0, + 0, 0, 110, 1731, 1, 0, 0, 0, 112, 1745, 1, 0, 0, 0, 114, 1747, 1, 0, 0, + 0, 116, 1759, 1, 0, 0, 0, 118, 1764, 1, 0, 0, 0, 120, 1773, 1, 0, 0, 0, + 122, 1778, 1, 0, 0, 0, 124, 1780, 1, 0, 0, 0, 126, 1782, 1, 0, 0, 0, 128, + 1864, 1, 0, 0, 0, 130, 1866, 1, 0, 0, 0, 132, 1868, 1, 0, 0, 0, 134, 1878, + 1, 0, 0, 0, 136, 1886, 1, 0, 0, 0, 138, 1892, 1, 0, 0, 0, 140, 1894, 1, + 0, 0, 0, 142, 1900, 1, 0, 0, 0, 144, 1913, 1, 0, 0, 0, 146, 1931, 1, 0, + 0, 0, 148, 1933, 1, 0, 0, 0, 150, 1944, 1, 0, 0, 0, 152, 1953, 1, 0, 0, + 0, 154, 1956, 1, 0, 0, 0, 156, 1964, 1, 0, 0, 0, 158, 1967, 1, 0, 0, 0, + 160, 1976, 1, 0, 0, 0, 162, 1979, 1, 0, 0, 0, 164, 1982, 1, 0, 0, 0, 166, + 1990, 1, 0, 0, 0, 168, 1995, 1, 0, 0, 0, 170, 1999, 1, 0, 0, 0, 172, 2005, + 1, 0, 0, 0, 174, 2008, 1, 0, 0, 0, 176, 2010, 1, 0, 0, 0, 178, 2016, 1, + 0, 0, 0, 180, 2031, 1, 0, 0, 0, 182, 2115, 1, 0, 0, 0, 184, 2121, 1, 0, + 0, 0, 186, 2123, 1, 0, 0, 0, 188, 2134, 1, 0, 0, 0, 190, 2138, 1, 0, 0, + 0, 192, 2186, 1, 0, 0, 0, 194, 2193, 1, 0, 0, 0, 196, 2196, 1, 0, 0, 0, + 198, 2203, 1, 0, 0, 0, 200, 2206, 1, 0, 0, 0, 202, 2210, 1, 0, 0, 0, 204, + 2217, 1, 0, 0, 0, 206, 2221, 1, 0, 0, 0, 208, 2254, 1, 0, 0, 0, 210, 2264, + 1, 0, 0, 0, 212, 2266, 1, 0, 0, 0, 214, 2279, 1, 0, 0, 0, 216, 2297, 1, + 0, 0, 0, 218, 2315, 1, 0, 0, 0, 220, 2330, 1, 0, 0, 0, 222, 2347, 1, 0, + 0, 0, 224, 2351, 1, 0, 0, 0, 226, 2365, 1, 0, 0, 0, 228, 2383, 1, 0, 0, + 0, 230, 2386, 1, 0, 0, 0, 232, 2391, 1, 0, 0, 0, 234, 2409, 1, 0, 0, 0, + 236, 2411, 1, 0, 0, 0, 238, 2419, 1, 0, 0, 0, 240, 2423, 1, 0, 0, 0, 242, + 2426, 1, 0, 0, 0, 244, 2433, 1, 0, 0, 0, 246, 2441, 1, 0, 0, 0, 248, 2449, + 1, 0, 0, 0, 250, 2452, 1, 0, 0, 0, 252, 2479, 1, 0, 0, 0, 254, 2484, 1, + 0, 0, 0, 256, 2495, 1, 0, 0, 0, 258, 2497, 1, 0, 0, 0, 260, 2505, 1, 0, + 0, 0, 262, 2508, 1, 0, 0, 0, 264, 2520, 1, 0, 0, 0, 266, 2548, 1, 0, 0, + 0, 268, 2551, 1, 0, 0, 0, 270, 2554, 1, 0, 0, 0, 272, 2577, 1, 0, 0, 0, + 274, 2587, 1, 0, 0, 0, 276, 2589, 1, 0, 0, 0, 278, 2606, 1, 0, 0, 0, 280, + 2610, 1, 0, 0, 0, 282, 2623, 1, 0, 0, 0, 284, 2664, 1, 0, 0, 0, 286, 2666, + 1, 0, 0, 0, 288, 2671, 1, 0, 0, 0, 290, 2674, 1, 0, 0, 0, 292, 2697, 1, + 0, 0, 0, 294, 2699, 1, 0, 0, 0, 296, 2707, 1, 0, 0, 0, 298, 2712, 1, 0, + 0, 0, 300, 2723, 1, 0, 0, 0, 302, 2737, 1, 0, 0, 0, 304, 2741, 1, 0, 0, + 0, 306, 2748, 1, 0, 0, 0, 308, 2751, 1, 0, 0, 0, 310, 2753, 1, 0, 0, 0, + 312, 2755, 1, 0, 0, 0, 314, 2785, 1, 0, 0, 0, 316, 2787, 1, 0, 0, 0, 318, + 2796, 1, 0, 0, 0, 320, 2802, 1, 0, 0, 0, 322, 2805, 1, 0, 0, 0, 324, 2815, + 1, 0, 0, 0, 326, 2831, 1, 0, 0, 0, 328, 2833, 1, 0, 0, 0, 330, 2840, 1, + 0, 0, 0, 332, 2842, 1, 0, 0, 0, 334, 2853, 1, 0, 0, 0, 336, 2861, 1, 0, + 0, 0, 338, 2864, 1, 0, 0, 0, 340, 2871, 1, 0, 0, 0, 342, 2886, 1, 0, 0, + 0, 344, 2888, 1, 0, 0, 0, 346, 2898, 1, 0, 0, 0, 348, 2911, 1, 0, 0, 0, + 350, 2921, 1, 0, 0, 0, 352, 2923, 1, 0, 0, 0, 354, 2940, 1, 0, 0, 0, 356, + 2944, 1, 0, 0, 0, 358, 2965, 1, 0, 0, 0, 360, 2969, 1, 0, 0, 0, 362, 2973, + 1, 0, 0, 0, 364, 2976, 1, 0, 0, 0, 366, 2980, 1, 0, 0, 0, 368, 2982, 1, + 0, 0, 0, 370, 3008, 1, 0, 0, 0, 372, 3010, 1, 0, 0, 0, 374, 3012, 1, 0, + 0, 0, 376, 3014, 1, 0, 0, 0, 378, 3050, 1, 0, 0, 0, 380, 3052, 1, 0, 0, + 0, 382, 3056, 1, 0, 0, 0, 384, 3062, 1, 0, 0, 0, 386, 3071, 1, 0, 0, 0, + 388, 3081, 1, 0, 0, 0, 390, 3092, 1, 0, 0, 0, 392, 3094, 1, 0, 0, 0, 394, + 3102, 1, 0, 0, 0, 396, 3104, 1, 0, 0, 0, 398, 3107, 1, 0, 0, 0, 400, 3109, + 1, 0, 0, 0, 402, 3112, 1, 0, 0, 0, 404, 3115, 1, 0, 0, 0, 406, 3146, 1, + 0, 0, 0, 408, 3148, 1, 0, 0, 0, 410, 3151, 1, 0, 0, 0, 412, 3157, 1, 0, + 0, 0, 414, 3159, 1, 0, 0, 0, 416, 3175, 1, 0, 0, 0, 418, 3177, 1, 0, 0, + 0, 420, 3185, 1, 0, 0, 0, 422, 3187, 1, 0, 0, 0, 424, 3189, 1, 0, 0, 0, + 426, 3195, 1, 0, 0, 0, 428, 3207, 1, 0, 0, 0, 430, 3222, 1, 0, 0, 0, 432, + 3225, 1, 0, 0, 0, 434, 3227, 1, 0, 0, 0, 436, 3230, 1, 0, 0, 0, 438, 3233, + 1, 0, 0, 0, 440, 3238, 1, 0, 0, 0, 442, 3242, 1, 0, 0, 0, 444, 3278, 1, + 0, 0, 0, 446, 3280, 1, 0, 0, 0, 448, 3288, 1, 0, 0, 0, 450, 3298, 1, 0, + 0, 0, 452, 3300, 1, 0, 0, 0, 454, 3320, 1, 0, 0, 0, 456, 3322, 1, 0, 0, + 0, 458, 3328, 1, 0, 0, 0, 460, 3347, 1, 0, 0, 0, 462, 3377, 1, 0, 0, 0, + 464, 3388, 1, 0, 0, 0, 466, 3393, 1, 0, 0, 0, 468, 3395, 1, 0, 0, 0, 470, + 3398, 1, 0, 0, 0, 472, 3401, 1, 0, 0, 0, 474, 3403, 1, 0, 0, 0, 476, 3408, + 1, 0, 0, 0, 478, 3410, 1, 0, 0, 0, 480, 3435, 1, 0, 0, 0, 482, 3495, 1, + 0, 0, 0, 484, 3516, 1, 0, 0, 0, 486, 3518, 1, 0, 0, 0, 488, 3526, 1, 0, + 0, 0, 490, 3528, 1, 0, 0, 0, 492, 3538, 1, 0, 0, 0, 494, 3540, 1, 0, 0, + 0, 496, 3544, 1, 0, 0, 0, 498, 3550, 1, 0, 0, 0, 500, 3552, 1, 0, 0, 0, + 502, 3563, 1, 0, 0, 0, 504, 3581, 1, 0, 0, 0, 506, 3583, 1, 0, 0, 0, 508, + 3588, 1, 0, 0, 0, 510, 3590, 1, 0, 0, 0, 512, 3599, 1, 0, 0, 0, 514, 3612, + 1, 0, 0, 0, 516, 3614, 1, 0, 0, 0, 518, 3627, 1, 0, 0, 0, 520, 3629, 1, + 0, 0, 0, 522, 3640, 1, 0, 0, 0, 524, 3706, 1, 0, 0, 0, 526, 3708, 1, 0, + 0, 0, 528, 3715, 1, 0, 0, 0, 530, 3720, 1, 0, 0, 0, 532, 3746, 1, 0, 0, + 0, 534, 3753, 1, 0, 0, 0, 536, 3762, 1, 0, 0, 0, 538, 3774, 1, 0, 0, 0, + 540, 3776, 1, 0, 0, 0, 542, 3782, 1, 0, 0, 0, 544, 3786, 1, 0, 0, 0, 546, + 3797, 1, 0, 0, 0, 548, 3811, 1, 0, 0, 0, 550, 3813, 1, 0, 0, 0, 552, 3831, + 1, 0, 0, 0, 554, 3839, 1, 0, 0, 0, 556, 3841, 1, 0, 0, 0, 558, 3843, 1, + 0, 0, 0, 560, 3846, 1, 0, 0, 0, 562, 3854, 1, 0, 0, 0, 564, 3858, 1, 0, + 0, 0, 566, 3885, 1, 0, 0, 0, 568, 3887, 1, 0, 0, 0, 570, 3893, 1, 0, 0, + 0, 572, 3901, 1, 0, 0, 0, 574, 3909, 1, 0, 0, 0, 576, 3913, 1, 0, 0, 0, + 578, 3919, 1, 0, 0, 0, 580, 3921, 1, 0, 0, 0, 582, 3923, 1, 0, 0, 0, 584, + 3944, 1, 0, 0, 0, 586, 3946, 1, 0, 0, 0, 588, 4147, 1, 0, 0, 0, 590, 4149, + 1, 0, 0, 0, 592, 4154, 1, 0, 0, 0, 594, 4170, 1, 0, 0, 0, 596, 4176, 1, + 0, 0, 0, 598, 4178, 1, 0, 0, 0, 600, 4180, 1, 0, 0, 0, 602, 4188, 1, 0, + 0, 0, 604, 4190, 1, 0, 0, 0, 606, 4199, 1, 0, 0, 0, 608, 4210, 1, 0, 0, + 0, 610, 4212, 1, 0, 0, 0, 612, 4216, 1, 0, 0, 0, 614, 4220, 1, 0, 0, 0, + 616, 4222, 1, 0, 0, 0, 618, 4233, 1, 0, 0, 0, 620, 4247, 1, 0, 0, 0, 622, + 4249, 1, 0, 0, 0, 624, 4251, 1, 0, 0, 0, 626, 4253, 1, 0, 0, 0, 628, 4266, + 1, 0, 0, 0, 630, 4268, 1, 0, 0, 0, 632, 4287, 1, 0, 0, 0, 634, 4291, 1, + 0, 0, 0, 636, 4295, 1, 0, 0, 0, 638, 4298, 1, 0, 0, 0, 640, 4304, 1, 0, + 0, 0, 642, 4314, 1, 0, 0, 0, 644, 4319, 1, 0, 0, 0, 646, 4331, 1, 0, 0, + 0, 648, 4333, 1, 0, 0, 0, 650, 4341, 1, 0, 0, 0, 652, 4343, 1, 0, 0, 0, + 654, 4348, 1, 0, 0, 0, 656, 4372, 1, 0, 0, 0, 658, 4376, 1, 0, 0, 0, 660, + 4378, 1, 0, 0, 0, 662, 4383, 1, 0, 0, 0, 664, 4393, 1, 0, 0, 0, 666, 4395, + 1, 0, 0, 0, 668, 4400, 1, 0, 0, 0, 670, 4402, 1, 0, 0, 0, 672, 4406, 1, + 0, 0, 0, 674, 4415, 1, 0, 0, 0, 676, 4428, 1, 0, 0, 0, 678, 4455, 1, 0, + 0, 0, 680, 4457, 1, 0, 0, 0, 682, 4474, 1, 0, 0, 0, 684, 4476, 1, 0, 0, + 0, 686, 4480, 1, 0, 0, 0, 688, 4490, 1, 0, 0, 0, 690, 4492, 1, 0, 0, 0, + 692, 4499, 1, 0, 0, 0, 694, 4501, 1, 0, 0, 0, 696, 4512, 1, 0, 0, 0, 698, + 4516, 1, 0, 0, 0, 700, 4522, 1, 0, 0, 0, 702, 4524, 1, 0, 0, 0, 704, 4527, + 1, 0, 0, 0, 706, 4531, 1, 0, 0, 0, 708, 4576, 1, 0, 0, 0, 710, 4578, 1, + 0, 0, 0, 712, 4580, 1, 0, 0, 0, 714, 4582, 1, 0, 0, 0, 716, 4585, 1, 0, + 0, 0, 718, 4589, 1, 0, 0, 0, 720, 4591, 1, 0, 0, 0, 722, 4605, 1, 0, 0, + 0, 724, 4617, 1, 0, 0, 0, 726, 4625, 1, 0, 0, 0, 728, 4628, 1, 0, 0, 0, + 730, 4644, 1, 0, 0, 0, 732, 4646, 1, 0, 0, 0, 734, 4648, 1, 0, 0, 0, 736, + 4650, 1, 0, 0, 0, 738, 4661, 1, 0, 0, 0, 740, 4663, 1, 0, 0, 0, 742, 4665, + 1, 0, 0, 0, 744, 4677, 1, 0, 0, 0, 746, 4683, 1, 0, 0, 0, 748, 4707, 1, + 0, 0, 0, 750, 4711, 1, 0, 0, 0, 752, 4716, 1, 0, 0, 0, 754, 4718, 1, 0, + 0, 0, 756, 4720, 1, 0, 0, 0, 758, 4733, 1, 0, 0, 0, 760, 4743, 1, 0, 0, + 0, 762, 4764, 1, 0, 0, 0, 764, 4777, 1, 0, 0, 0, 766, 4791, 1, 0, 0, 0, + 768, 4793, 1, 0, 0, 0, 770, 4795, 1, 0, 0, 0, 772, 4804, 1, 0, 0, 0, 774, + 4808, 1, 0, 0, 0, 776, 4811, 1, 0, 0, 0, 778, 4816, 1, 0, 0, 0, 780, 4818, + 1, 0, 0, 0, 782, 4850, 1, 0, 0, 0, 784, 4856, 1, 0, 0, 0, 786, 4865, 1, + 0, 0, 0, 788, 4867, 1, 0, 0, 0, 790, 4883, 1, 0, 0, 0, 792, 4904, 1, 0, + 0, 0, 794, 4914, 1, 0, 0, 0, 796, 4941, 1, 0, 0, 0, 798, 4986, 1, 0, 0, + 0, 800, 4989, 1, 0, 0, 0, 802, 4993, 1, 0, 0, 0, 804, 5019, 1, 0, 0, 0, + 806, 5021, 1, 0, 0, 0, 808, 5028, 1, 0, 0, 0, 810, 5030, 1, 0, 0, 0, 812, + 5040, 1, 0, 0, 0, 814, 5047, 1, 0, 0, 0, 816, 5049, 1, 0, 0, 0, 818, 5051, + 1, 0, 0, 0, 820, 5061, 1, 0, 0, 0, 822, 5079, 1, 0, 0, 0, 824, 5090, 1, + 0, 0, 0, 826, 5105, 1, 0, 0, 0, 828, 5107, 1, 0, 0, 0, 830, 5115, 1, 0, + 0, 0, 832, 5119, 1, 0, 0, 0, 834, 5123, 1, 0, 0, 0, 836, 5131, 1, 0, 0, + 0, 838, 5148, 1, 0, 0, 0, 840, 5154, 1, 0, 0, 0, 842, 5156, 1, 0, 0, 0, + 844, 5168, 1, 0, 0, 0, 846, 5170, 1, 0, 0, 0, 848, 5194, 1, 0, 0, 0, 850, + 5196, 1, 0, 0, 0, 852, 5246, 1, 0, 0, 0, 854, 5268, 1, 0, 0, 0, 856, 5272, + 1, 0, 0, 0, 858, 5276, 1, 0, 0, 0, 860, 5278, 1, 0, 0, 0, 862, 5303, 1, + 0, 0, 0, 864, 5321, 1, 0, 0, 0, 866, 5342, 1, 0, 0, 0, 868, 5344, 1, 0, + 0, 0, 870, 5354, 1, 0, 0, 0, 872, 5366, 1, 0, 0, 0, 874, 5368, 1, 0, 0, + 0, 876, 5378, 1, 0, 0, 0, 878, 5381, 1, 0, 0, 0, 880, 5385, 1, 0, 0, 0, + 882, 5424, 1, 0, 0, 0, 884, 5426, 1, 0, 0, 0, 886, 5431, 1, 0, 0, 0, 888, + 5433, 1, 0, 0, 0, 890, 5438, 1, 0, 0, 0, 892, 5446, 1, 0, 0, 0, 894, 5452, + 1, 0, 0, 0, 896, 5454, 1, 0, 0, 0, 898, 5457, 1, 0, 0, 0, 900, 5460, 1, + 0, 0, 0, 902, 5472, 1, 0, 0, 0, 904, 5475, 1, 0, 0, 0, 906, 5487, 1, 0, + 0, 0, 908, 5499, 1, 0, 0, 0, 910, 5506, 1, 0, 0, 0, 912, 5508, 1, 0, 0, + 0, 914, 5520, 1, 0, 0, 0, 916, 5522, 1, 0, 0, 0, 918, 5533, 1, 0, 0, 0, + 920, 5541, 1, 0, 0, 0, 922, 5545, 1, 0, 0, 0, 924, 5553, 1, 0, 0, 0, 926, + 5560, 1, 0, 0, 0, 928, 5576, 1, 0, 0, 0, 930, 5578, 1, 0, 0, 0, 932, 5580, + 1, 0, 0, 0, 934, 5583, 1, 0, 0, 0, 936, 5597, 1, 0, 0, 0, 938, 5599, 1, + 0, 0, 0, 940, 5608, 1, 0, 0, 0, 942, 5610, 1, 0, 0, 0, 944, 5621, 1, 0, + 0, 0, 946, 5623, 1, 0, 0, 0, 948, 5635, 1, 0, 0, 0, 950, 5647, 1, 0, 0, + 0, 952, 5654, 1, 0, 0, 0, 954, 5700, 1, 0, 0, 0, 956, 5961, 1, 0, 0, 0, + 958, 5971, 1, 0, 0, 0, 960, 5973, 1, 0, 0, 0, 962, 5975, 1, 0, 0, 0, 964, + 5977, 1, 0, 0, 0, 966, 5979, 1, 0, 0, 0, 968, 5981, 1, 0, 0, 0, 970, 5983, + 1, 0, 0, 0, 972, 5988, 1, 0, 0, 0, 974, 5993, 1, 0, 0, 0, 976, 5997, 1, + 0, 0, 0, 978, 6004, 1, 0, 0, 0, 980, 6008, 1, 0, 0, 0, 982, 6017, 1, 0, + 0, 0, 984, 6019, 1, 0, 0, 0, 986, 6029, 1, 0, 0, 0, 988, 6040, 1, 0, 0, + 0, 990, 6045, 1, 0, 0, 0, 992, 6054, 1, 0, 0, 0, 994, 6065, 1, 0, 0, 0, + 996, 6067, 1, 0, 0, 0, 998, 6076, 1, 0, 0, 0, 1000, 6080, 1, 0, 0, 0, 1002, + 6096, 1, 0, 0, 0, 1004, 6098, 1, 0, 0, 0, 1006, 6116, 1, 0, 0, 0, 1008, + 6158, 1, 0, 0, 0, 1010, 6169, 1, 0, 0, 0, 1012, 6187, 1, 0, 0, 0, 1014, + 6198, 1, 0, 0, 0, 1016, 6207, 1, 0, 0, 0, 1018, 6209, 1, 0, 0, 0, 1020, + 6211, 1, 0, 0, 0, 1022, 6213, 1, 0, 0, 0, 1024, 6215, 1, 0, 0, 0, 1026, + 6228, 1, 0, 0, 0, 1028, 6232, 1, 0, 0, 0, 1030, 6236, 1, 0, 0, 0, 1032, + 6241, 1, 0, 0, 0, 1034, 6248, 1, 0, 0, 0, 1036, 6250, 1, 0, 0, 0, 1038, + 6259, 1, 0, 0, 0, 1040, 6265, 1, 0, 0, 0, 1042, 6267, 1, 0, 0, 0, 1044, + 6273, 1, 0, 0, 0, 1046, 6284, 1, 0, 0, 0, 1048, 6286, 1, 0, 0, 0, 1050, + 6297, 1, 0, 0, 0, 1052, 6299, 1, 0, 0, 0, 1054, 6306, 1, 0, 0, 0, 1056, + 6315, 1, 0, 0, 0, 1058, 6325, 1, 0, 0, 0, 1060, 6327, 1, 0, 0, 0, 1062, + 6336, 1, 0, 0, 0, 1064, 6345, 1, 0, 0, 0, 1066, 6351, 1, 0, 0, 0, 1068, + 6353, 1, 0, 0, 0, 1070, 6356, 1, 0, 0, 0, 1072, 6381, 1, 0, 0, 0, 1074, + 6385, 1, 0, 0, 0, 1076, 6387, 1, 0, 0, 0, 1078, 6407, 1, 0, 0, 0, 1080, + 6409, 1, 0, 0, 0, 1082, 6429, 1, 0, 0, 0, 1084, 6431, 1, 0, 0, 0, 1086, + 6440, 1, 0, 0, 0, 1088, 6450, 1, 0, 0, 0, 1090, 6455, 1, 0, 0, 0, 1092, + 6457, 1, 0, 0, 0, 1094, 6461, 1, 0, 0, 0, 1096, 6467, 1, 0, 0, 0, 1098, + 6469, 1, 0, 0, 0, 1100, 6471, 1, 0, 0, 0, 1102, 6474, 1, 0, 0, 0, 1104, + 6494, 1, 0, 0, 0, 1106, 6496, 1, 0, 0, 0, 1108, 6515, 1, 0, 0, 0, 1110, + 6534, 1, 0, 0, 0, 1112, 6541, 1, 0, 0, 0, 1114, 6549, 1, 0, 0, 0, 1116, + 6563, 1, 0, 0, 0, 1118, 6565, 1, 0, 0, 0, 1120, 6571, 1, 0, 0, 0, 1122, + 6576, 1, 0, 0, 0, 1124, 6609, 1, 0, 0, 0, 1126, 6619, 1, 0, 0, 0, 1128, + 6623, 1, 0, 0, 0, 1130, 6625, 1, 0, 0, 0, 1132, 6636, 1, 0, 0, 0, 1134, + 6651, 1, 0, 0, 0, 1136, 6653, 1, 0, 0, 0, 1138, 6665, 1, 0, 0, 0, 1140, + 6667, 1, 0, 0, 0, 1142, 6676, 1, 0, 0, 0, 1144, 6691, 1, 0, 0, 0, 1146, + 6694, 1, 0, 0, 0, 1148, 6699, 1, 0, 0, 0, 1150, 6701, 1, 0, 0, 0, 1152, + 6711, 1, 0, 0, 0, 1154, 6713, 1, 0, 0, 0, 1156, 6722, 1, 0, 0, 0, 1158, + 6737, 1, 0, 0, 0, 1160, 6745, 1, 0, 0, 0, 1162, 6747, 1, 0, 0, 0, 1164, + 6762, 1, 0, 0, 0, 1166, 6764, 1, 0, 0, 0, 1168, 6767, 1, 0, 0, 0, 1170, + 6772, 1, 0, 0, 0, 1172, 6779, 1, 0, 0, 0, 1174, 6785, 1, 0, 0, 0, 1176, + 6787, 1, 0, 0, 0, 1178, 6792, 1, 0, 0, 0, 1180, 6794, 1, 0, 0, 0, 1182, + 6805, 1, 0, 0, 0, 1184, 6807, 1, 0, 0, 0, 1186, 6822, 1, 0, 0, 0, 1188, + 6830, 1, 0, 0, 0, 1190, 6832, 1, 0, 0, 0, 1192, 6860, 1, 0, 0, 0, 1194, + 6862, 1, 0, 0, 0, 1196, 6875, 1, 0, 0, 0, 1198, 6877, 1, 0, 0, 0, 1200, + 6887, 1, 0, 0, 0, 1202, 6891, 1, 0, 0, 0, 1204, 6893, 1, 0, 0, 0, 1206, + 6895, 1, 0, 0, 0, 1208, 6904, 1, 0, 0, 0, 1210, 6906, 1, 0, 0, 0, 1212, + 6920, 1, 0, 0, 0, 1214, 6922, 1, 0, 0, 0, 1216, 6927, 1, 0, 0, 0, 1218, + 6929, 1, 0, 0, 0, 1220, 6931, 1, 0, 0, 0, 1222, 6934, 1, 0, 0, 0, 1224, + 6936, 1, 0, 0, 0, 1226, 6938, 1, 0, 0, 0, 1228, 6941, 1, 0, 0, 0, 1230, + 6944, 1, 0, 0, 0, 1232, 6946, 1, 0, 0, 0, 1234, 6949, 1, 0, 0, 0, 1236, + 6951, 1, 0, 0, 0, 1238, 6953, 1, 0, 0, 0, 1240, 6969, 1, 0, 0, 0, 1242, + 6971, 1, 0, 0, 0, 1244, 6973, 1, 0, 0, 0, 1246, 6989, 1, 0, 0, 0, 1248, + 6991, 1, 0, 0, 0, 1250, 1251, 3, 2, 1, 0, 1251, 1252, 5, 0, 0, 1, 1252, + 1, 1, 0, 0, 0, 1253, 1258, 3, 4, 2, 0, 1254, 1255, 5, 27, 0, 0, 1255, 1257, + 3, 4, 2, 0, 1256, 1254, 1, 0, 0, 0, 1257, 1260, 1, 0, 0, 0, 1258, 1256, + 1, 0, 0, 0, 1258, 1259, 1, 0, 0, 0, 1259, 1262, 1, 0, 0, 0, 1260, 1258, + 1, 0, 0, 0, 1261, 1263, 5, 27, 0, 0, 1262, 1261, 1, 0, 0, 0, 1262, 1263, + 1, 0, 0, 0, 1263, 3, 1, 0, 0, 0, 1264, 1266, 3, 472, 236, 0, 1265, 1264, + 1, 0, 0, 0, 1265, 1266, 1, 0, 0, 0, 1266, 1267, 1, 0, 0, 0, 1267, 1277, + 3, 6, 3, 0, 1268, 1269, 5, 327, 0, 0, 1269, 1270, 5, 202, 0, 0, 1270, 1277, + 6, 2, -1, 0, 1271, 1272, 3, 472, 236, 0, 1272, 1273, 5, 327, 0, 0, 1273, + 1274, 5, 202, 0, 0, 1274, 1275, 6, 2, -1, 0, 1275, 1277, 1, 0, 0, 0, 1276, + 1265, 1, 0, 0, 0, 1276, 1268, 1, 0, 0, 0, 1276, 1271, 1, 0, 0, 0, 1277, + 5, 1, 0, 0, 0, 1278, 1332, 3, 474, 237, 0, 1279, 1332, 3, 524, 262, 0, + 1280, 1332, 3, 526, 263, 0, 1281, 1332, 3, 528, 264, 0, 1282, 1332, 3, + 530, 265, 0, 1283, 1332, 3, 532, 266, 0, 1284, 1332, 3, 476, 238, 0, 1285, + 1332, 3, 458, 229, 0, 1286, 1332, 3, 456, 228, 0, 1287, 1332, 3, 448, 224, + 0, 1288, 1332, 3, 444, 222, 0, 1289, 1332, 3, 442, 221, 0, 1290, 1332, + 3, 438, 219, 0, 1291, 1332, 3, 434, 217, 0, 1292, 1332, 3, 436, 218, 0, + 1293, 1332, 3, 428, 214, 0, 1294, 1332, 3, 426, 213, 0, 1295, 1332, 3, + 424, 212, 0, 1296, 1332, 3, 376, 188, 0, 1297, 1332, 3, 312, 156, 0, 1298, + 1332, 3, 282, 141, 0, 1299, 1332, 3, 276, 138, 0, 1300, 1332, 3, 270, 135, + 0, 1301, 1332, 3, 264, 132, 0, 1302, 1332, 3, 262, 131, 0, 1303, 1332, + 3, 250, 125, 0, 1304, 1332, 3, 220, 110, 0, 1305, 1332, 3, 218, 109, 0, + 1306, 1332, 3, 216, 108, 0, 1307, 1332, 3, 214, 107, 0, 1308, 1332, 3, + 206, 103, 0, 1309, 1332, 3, 190, 95, 0, 1310, 1332, 3, 182, 91, 0, 1311, + 1332, 3, 178, 89, 0, 1312, 1332, 3, 176, 88, 0, 1313, 1332, 3, 168, 84, + 0, 1314, 1332, 3, 158, 79, 0, 1315, 1332, 3, 156, 78, 0, 1316, 1332, 3, + 152, 76, 0, 1317, 1332, 3, 150, 75, 0, 1318, 1332, 3, 148, 74, 0, 1319, + 1332, 3, 8, 4, 0, 1320, 1332, 3, 144, 72, 0, 1321, 1332, 3, 140, 70, 0, + 1322, 1332, 3, 142, 71, 0, 1323, 1332, 3, 440, 220, 0, 1324, 1332, 3, 134, + 67, 0, 1325, 1332, 3, 132, 66, 0, 1326, 1332, 3, 128, 64, 0, 1327, 1332, + 3, 126, 63, 0, 1328, 1332, 3, 118, 59, 0, 1329, 1332, 3, 116, 58, 0, 1330, + 1332, 3, 114, 57, 0, 1331, 1278, 1, 0, 0, 0, 1331, 1279, 1, 0, 0, 0, 1331, + 1280, 1, 0, 0, 0, 1331, 1281, 1, 0, 0, 0, 1331, 1282, 1, 0, 0, 0, 1331, + 1283, 1, 0, 0, 0, 1331, 1284, 1, 0, 0, 0, 1331, 1285, 1, 0, 0, 0, 1331, + 1286, 1, 0, 0, 0, 1331, 1287, 1, 0, 0, 0, 1331, 1288, 1, 0, 0, 0, 1331, + 1289, 1, 0, 0, 0, 1331, 1290, 1, 0, 0, 0, 1331, 1291, 1, 0, 0, 0, 1331, + 1292, 1, 0, 0, 0, 1331, 1293, 1, 0, 0, 0, 1331, 1294, 1, 0, 0, 0, 1331, + 1295, 1, 0, 0, 0, 1331, 1296, 1, 0, 0, 0, 1331, 1297, 1, 0, 0, 0, 1331, + 1298, 1, 0, 0, 0, 1331, 1299, 1, 0, 0, 0, 1331, 1300, 1, 0, 0, 0, 1331, + 1301, 1, 0, 0, 0, 1331, 1302, 1, 0, 0, 0, 1331, 1303, 1, 0, 0, 0, 1331, + 1304, 1, 0, 0, 0, 1331, 1305, 1, 0, 0, 0, 1331, 1306, 1, 0, 0, 0, 1331, + 1307, 1, 0, 0, 0, 1331, 1308, 1, 0, 0, 0, 1331, 1309, 1, 0, 0, 0, 1331, + 1310, 1, 0, 0, 0, 1331, 1311, 1, 0, 0, 0, 1331, 1312, 1, 0, 0, 0, 1331, + 1313, 1, 0, 0, 0, 1331, 1314, 1, 0, 0, 0, 1331, 1315, 1, 0, 0, 0, 1331, + 1316, 1, 0, 0, 0, 1331, 1317, 1, 0, 0, 0, 1331, 1318, 1, 0, 0, 0, 1331, + 1319, 1, 0, 0, 0, 1331, 1320, 1, 0, 0, 0, 1331, 1321, 1, 0, 0, 0, 1331, + 1322, 1, 0, 0, 0, 1331, 1323, 1, 0, 0, 0, 1331, 1324, 1, 0, 0, 0, 1331, + 1325, 1, 0, 0, 0, 1331, 1326, 1, 0, 0, 0, 1331, 1327, 1, 0, 0, 0, 1331, + 1328, 1, 0, 0, 0, 1331, 1329, 1, 0, 0, 0, 1331, 1330, 1, 0, 0, 0, 1332, + 7, 1, 0, 0, 0, 1333, 1334, 5, 347, 0, 0, 1334, 1335, 3, 1198, 599, 0, 1335, + 1336, 3, 10, 5, 0, 1336, 9, 1, 0, 0, 0, 1337, 1342, 3, 12, 6, 0, 1338, + 1339, 5, 352, 0, 0, 1339, 1341, 3, 12, 6, 0, 1340, 1338, 1, 0, 0, 0, 1341, + 1344, 1, 0, 0, 0, 1342, 1340, 1, 0, 0, 0, 1342, 1343, 1, 0, 0, 0, 1343, + 11, 1, 0, 0, 0, 1344, 1342, 1, 0, 0, 0, 1345, 1348, 3, 18, 9, 0, 1346, + 1348, 3, 14, 7, 0, 1347, 1345, 1, 0, 0, 0, 1347, 1346, 1, 0, 0, 0, 1348, + 13, 1, 0, 0, 0, 1349, 1350, 3, 18, 9, 0, 1350, 1351, 3, 16, 8, 0, 1351, + 1357, 3, 18, 9, 0, 1352, 1353, 3, 16, 8, 0, 1353, 1354, 3, 18, 9, 0, 1354, + 1356, 1, 0, 0, 0, 1355, 1352, 1, 0, 0, 0, 1356, 1359, 1, 0, 0, 0, 1357, + 1355, 1, 0, 0, 0, 1357, 1358, 1, 0, 0, 0, 1358, 15, 1, 0, 0, 0, 1359, 1357, + 1, 0, 0, 0, 1360, 1361, 3, 736, 368, 0, 1361, 1362, 3, 734, 367, 0, 1362, + 17, 1, 0, 0, 0, 1363, 1365, 3, 20, 10, 0, 1364, 1363, 1, 0, 0, 0, 1364, + 1365, 1, 0, 0, 0, 1365, 1366, 1, 0, 0, 0, 1366, 1367, 3, 100, 50, 0, 1367, + 19, 1, 0, 0, 0, 1368, 1370, 3, 22, 11, 0, 1369, 1368, 1, 0, 0, 0, 1370, + 1371, 1, 0, 0, 0, 1371, 1369, 1, 0, 0, 0, 1371, 1372, 1, 0, 0, 0, 1372, + 21, 1, 0, 0, 0, 1373, 1383, 3, 48, 24, 0, 1374, 1383, 3, 46, 23, 0, 1375, + 1383, 3, 40, 20, 0, 1376, 1383, 3, 38, 19, 0, 1377, 1383, 3, 36, 18, 0, + 1378, 1383, 3, 34, 17, 0, 1379, 1383, 3, 32, 16, 0, 1380, 1383, 3, 28, + 14, 0, 1381, 1383, 3, 24, 12, 0, 1382, 1373, 1, 0, 0, 0, 1382, 1374, 1, + 0, 0, 0, 1382, 1375, 1, 0, 0, 0, 1382, 1376, 1, 0, 0, 0, 1382, 1377, 1, + 0, 0, 0, 1382, 1378, 1, 0, 0, 0, 1382, 1379, 1, 0, 0, 0, 1382, 1380, 1, + 0, 0, 0, 1382, 1381, 1, 0, 0, 0, 1383, 23, 1, 0, 0, 0, 1384, 1385, 5, 99, + 0, 0, 1385, 1386, 3, 1200, 600, 0, 1386, 1387, 5, 21, 0, 0, 1387, 1388, + 3, 812, 406, 0, 1388, 1390, 5, 22, 0, 0, 1389, 1391, 3, 26, 13, 0, 1390, + 1389, 1, 0, 0, 0, 1390, 1391, 1, 0, 0, 0, 1391, 25, 1, 0, 0, 0, 1392, 1406, + 3, 806, 403, 0, 1393, 1394, 5, 104, 0, 0, 1394, 1396, 5, 287, 0, 0, 1395, + 1397, 3, 806, 403, 0, 1396, 1395, 1, 0, 0, 0, 1396, 1397, 1, 0, 0, 0, 1397, + 1406, 1, 0, 0, 0, 1398, 1399, 5, 104, 0, 0, 1399, 1400, 5, 287, 0, 0, 1400, + 1401, 5, 58, 0, 0, 1401, 1403, 3, 1200, 600, 0, 1402, 1404, 3, 806, 403, + 0, 1403, 1402, 1, 0, 0, 0, 1403, 1404, 1, 0, 0, 0, 1404, 1406, 1, 0, 0, + 0, 1405, 1392, 1, 0, 0, 0, 1405, 1393, 1, 0, 0, 0, 1405, 1398, 1, 0, 0, + 0, 1406, 27, 1, 0, 0, 0, 1407, 1408, 5, 70, 0, 0, 1408, 1409, 3, 1200, + 600, 0, 1409, 1410, 5, 73, 0, 0, 1410, 1412, 3, 952, 476, 0, 1411, 1413, + 3, 30, 15, 0, 1412, 1411, 1, 0, 0, 0, 1412, 1413, 1, 0, 0, 0, 1413, 29, + 1, 0, 0, 0, 1414, 1415, 5, 104, 0, 0, 1415, 1417, 5, 83, 0, 0, 1416, 1418, + 3, 1088, 544, 0, 1417, 1416, 1, 0, 0, 0, 1417, 1418, 1, 0, 0, 0, 1418, + 31, 1, 0, 0, 0, 1419, 1421, 5, 104, 0, 0, 1420, 1422, 3, 734, 367, 0, 1421, + 1420, 1, 0, 0, 0, 1421, 1422, 1, 0, 0, 0, 1422, 1424, 1, 0, 0, 0, 1423, + 1425, 3, 1066, 533, 0, 1424, 1423, 1, 0, 0, 0, 1424, 1425, 1, 0, 0, 0, + 1425, 1426, 1, 0, 0, 0, 1426, 1428, 3, 110, 55, 0, 1427, 1429, 3, 778, + 389, 0, 1428, 1427, 1, 0, 0, 0, 1428, 1429, 1, 0, 0, 0, 1429, 33, 1, 0, + 0, 0, 1430, 1431, 3, 102, 51, 0, 1431, 35, 1, 0, 0, 0, 1432, 1433, 3, 104, + 52, 0, 1433, 37, 1, 0, 0, 0, 1434, 1435, 5, 173, 0, 0, 1435, 1439, 3, 774, + 387, 0, 1436, 1437, 5, 173, 0, 0, 1437, 1439, 3, 952, 476, 0, 1438, 1434, + 1, 0, 0, 0, 1438, 1436, 1, 0, 0, 0, 1439, 39, 1, 0, 0, 0, 1440, 1441, 5, + 363, 0, 0, 1441, 1442, 3, 42, 21, 0, 1442, 41, 1, 0, 0, 0, 1443, 1448, + 3, 44, 22, 0, 1444, 1445, 5, 17, 0, 0, 1445, 1447, 3, 44, 22, 0, 1446, + 1444, 1, 0, 0, 0, 1447, 1450, 1, 0, 0, 0, 1448, 1446, 1, 0, 0, 0, 1448, + 1449, 1, 0, 0, 0, 1449, 43, 1, 0, 0, 0, 1450, 1448, 1, 0, 0, 0, 1451, 1452, + 3, 1200, 600, 0, 1452, 1453, 5, 1, 0, 0, 1453, 1454, 3, 952, 476, 0, 1454, + 45, 1, 0, 0, 0, 1455, 1456, 5, 362, 0, 0, 1456, 1458, 5, 204, 0, 0, 1457, + 1459, 3, 1066, 533, 0, 1458, 1457, 1, 0, 0, 0, 1458, 1459, 1, 0, 0, 0, + 1459, 1460, 1, 0, 0, 0, 1460, 1461, 3, 50, 25, 0, 1461, 47, 1, 0, 0, 0, + 1462, 1464, 5, 204, 0, 0, 1463, 1465, 3, 1066, 533, 0, 1464, 1463, 1, 0, + 0, 0, 1464, 1465, 1, 0, 0, 0, 1465, 1466, 1, 0, 0, 0, 1466, 1467, 3, 50, + 25, 0, 1467, 49, 1, 0, 0, 0, 1468, 1470, 3, 52, 26, 0, 1469, 1471, 3, 774, + 387, 0, 1470, 1469, 1, 0, 0, 0, 1470, 1471, 1, 0, 0, 0, 1471, 51, 1, 0, + 0, 0, 1472, 1480, 3, 54, 27, 0, 1473, 1475, 5, 17, 0, 0, 1474, 1476, 3, + 1066, 533, 0, 1475, 1474, 1, 0, 0, 0, 1475, 1476, 1, 0, 0, 0, 1476, 1477, + 1, 0, 0, 0, 1477, 1479, 3, 54, 27, 0, 1478, 1473, 1, 0, 0, 0, 1479, 1482, + 1, 0, 0, 0, 1480, 1478, 1, 0, 0, 0, 1480, 1481, 1, 0, 0, 0, 1481, 53, 1, + 0, 0, 0, 1482, 1480, 1, 0, 0, 0, 1483, 1485, 3, 96, 48, 0, 1484, 1483, + 1, 0, 0, 0, 1484, 1485, 1, 0, 0, 0, 1485, 1487, 1, 0, 0, 0, 1486, 1488, + 3, 94, 47, 0, 1487, 1486, 1, 0, 0, 0, 1487, 1488, 1, 0, 0, 0, 1488, 1490, + 1, 0, 0, 0, 1489, 1491, 3, 88, 44, 0, 1490, 1489, 1, 0, 0, 0, 1490, 1491, + 1, 0, 0, 0, 1491, 1492, 1, 0, 0, 0, 1492, 1493, 3, 56, 28, 0, 1493, 55, + 1, 0, 0, 0, 1494, 1501, 3, 58, 29, 0, 1495, 1497, 3, 1066, 533, 0, 1496, + 1495, 1, 0, 0, 0, 1496, 1497, 1, 0, 0, 0, 1497, 1498, 1, 0, 0, 0, 1498, + 1500, 3, 58, 29, 0, 1499, 1496, 1, 0, 0, 0, 1500, 1503, 1, 0, 0, 0, 1501, + 1499, 1, 0, 0, 0, 1501, 1502, 1, 0, 0, 0, 1502, 57, 1, 0, 0, 0, 1503, 1501, + 1, 0, 0, 0, 1504, 1507, 3, 62, 31, 0, 1505, 1507, 3, 60, 30, 0, 1506, 1504, + 1, 0, 0, 0, 1506, 1505, 1, 0, 0, 0, 1507, 59, 1, 0, 0, 0, 1508, 1509, 3, + 62, 31, 0, 1509, 1511, 5, 19, 0, 0, 1510, 1512, 3, 752, 376, 0, 1511, 1510, + 1, 0, 0, 0, 1511, 1512, 1, 0, 0, 0, 1512, 1513, 1, 0, 0, 0, 1513, 1514, + 5, 17, 0, 0, 1514, 1515, 3, 752, 376, 0, 1515, 1516, 5, 20, 0, 0, 1516, + 1523, 1, 0, 0, 0, 1517, 1518, 3, 62, 31, 0, 1518, 1519, 5, 19, 0, 0, 1519, + 1520, 3, 752, 376, 0, 1520, 1521, 5, 20, 0, 0, 1521, 1523, 1, 0, 0, 0, + 1522, 1508, 1, 0, 0, 0, 1522, 1517, 1, 0, 0, 0, 1523, 61, 1, 0, 0, 0, 1524, + 1527, 3, 66, 33, 0, 1525, 1527, 3, 64, 32, 0, 1526, 1524, 1, 0, 0, 0, 1526, + 1525, 1, 0, 0, 0, 1527, 63, 1, 0, 0, 0, 1528, 1530, 5, 21, 0, 0, 1529, + 1531, 3, 1066, 533, 0, 1530, 1529, 1, 0, 0, 0, 1530, 1531, 1, 0, 0, 0, + 1531, 1532, 1, 0, 0, 0, 1532, 1534, 3, 54, 27, 0, 1533, 1535, 3, 774, 387, + 0, 1534, 1533, 1, 0, 0, 0, 1534, 1535, 1, 0, 0, 0, 1535, 1536, 1, 0, 0, + 0, 1536, 1537, 5, 22, 0, 0, 1537, 65, 1, 0, 0, 0, 1538, 1541, 3, 70, 35, + 0, 1539, 1541, 3, 68, 34, 0, 1540, 1538, 1, 0, 0, 0, 1540, 1539, 1, 0, + 0, 0, 1541, 67, 1, 0, 0, 0, 1542, 1544, 5, 4, 0, 0, 1543, 1542, 1, 0, 0, + 0, 1543, 1544, 1, 0, 0, 0, 1544, 1545, 1, 0, 0, 0, 1545, 1546, 5, 11, 0, + 0, 1546, 1547, 5, 23, 0, 0, 1547, 1548, 3, 72, 36, 0, 1548, 1549, 5, 24, + 0, 0, 1549, 1550, 5, 11, 0, 0, 1550, 1562, 1, 0, 0, 0, 1551, 1552, 5, 11, + 0, 0, 1552, 1553, 5, 23, 0, 0, 1553, 1554, 3, 72, 36, 0, 1554, 1555, 5, + 24, 0, 0, 1555, 1556, 5, 37, 0, 0, 1556, 1562, 1, 0, 0, 0, 1557, 1562, + 5, 11, 0, 0, 1558, 1559, 5, 4, 0, 0, 1559, 1562, 5, 11, 0, 0, 1560, 1562, + 5, 37, 0, 0, 1561, 1543, 1, 0, 0, 0, 1561, 1551, 1, 0, 0, 0, 1561, 1557, + 1, 0, 0, 0, 1561, 1558, 1, 0, 0, 0, 1561, 1560, 1, 0, 0, 0, 1562, 69, 1, + 0, 0, 0, 1563, 1564, 5, 21, 0, 0, 1564, 1565, 3, 72, 36, 0, 1565, 1566, + 5, 22, 0, 0, 1566, 71, 1, 0, 0, 0, 1567, 1569, 3, 1066, 533, 0, 1568, 1567, + 1, 0, 0, 0, 1568, 1569, 1, 0, 0, 0, 1569, 1571, 1, 0, 0, 0, 1570, 1572, + 3, 86, 43, 0, 1571, 1570, 1, 0, 0, 0, 1571, 1572, 1, 0, 0, 0, 1572, 1574, + 1, 0, 0, 0, 1573, 1575, 3, 78, 39, 0, 1574, 1573, 1, 0, 0, 0, 1574, 1575, + 1, 0, 0, 0, 1575, 1577, 1, 0, 0, 0, 1576, 1578, 3, 74, 37, 0, 1577, 1576, + 1, 0, 0, 0, 1577, 1578, 1, 0, 0, 0, 1578, 1599, 1, 0, 0, 0, 1579, 1581, + 3, 1066, 533, 0, 1580, 1579, 1, 0, 0, 0, 1580, 1581, 1, 0, 0, 0, 1581, + 1582, 1, 0, 0, 0, 1582, 1584, 3, 86, 43, 0, 1583, 1585, 3, 78, 39, 0, 1584, + 1583, 1, 0, 0, 0, 1584, 1585, 1, 0, 0, 0, 1585, 1586, 1, 0, 0, 0, 1586, + 1587, 3, 774, 387, 0, 1587, 1599, 1, 0, 0, 0, 1588, 1590, 3, 1066, 533, + 0, 1589, 1588, 1, 0, 0, 0, 1589, 1590, 1, 0, 0, 0, 1590, 1591, 1, 0, 0, + 0, 1591, 1593, 3, 86, 43, 0, 1592, 1594, 3, 78, 39, 0, 1593, 1592, 1, 0, + 0, 0, 1593, 1594, 1, 0, 0, 0, 1594, 1595, 1, 0, 0, 0, 1595, 1596, 3, 74, + 37, 0, 1596, 1597, 3, 774, 387, 0, 1597, 1599, 1, 0, 0, 0, 1598, 1568, + 1, 0, 0, 0, 1598, 1580, 1, 0, 0, 0, 1598, 1589, 1, 0, 0, 0, 1599, 73, 1, + 0, 0, 0, 1600, 1601, 5, 19, 0, 0, 1601, 1606, 3, 76, 38, 0, 1602, 1603, + 5, 17, 0, 0, 1603, 1605, 3, 76, 38, 0, 1604, 1602, 1, 0, 0, 0, 1605, 1608, + 1, 0, 0, 0, 1606, 1604, 1, 0, 0, 0, 1606, 1607, 1, 0, 0, 0, 1607, 1609, + 1, 0, 0, 0, 1608, 1606, 1, 0, 0, 0, 1609, 1610, 5, 20, 0, 0, 1610, 75, + 1, 0, 0, 0, 1611, 1612, 3, 1200, 600, 0, 1612, 1613, 5, 26, 0, 0, 1613, + 1614, 3, 952, 476, 0, 1614, 77, 1, 0, 0, 0, 1615, 1616, 5, 336, 0, 0, 1616, + 1620, 3, 80, 40, 0, 1617, 1618, 5, 26, 0, 0, 1618, 1620, 3, 80, 40, 0, + 1619, 1615, 1, 0, 0, 0, 1619, 1617, 1, 0, 0, 0, 1620, 79, 1, 0, 0, 0, 1621, + 1622, 6, 40, -1, 0, 1622, 1626, 3, 82, 41, 0, 1623, 1624, 5, 15, 0, 0, + 1624, 1626, 3, 80, 40, 1, 1625, 1621, 1, 0, 0, 0, 1625, 1623, 1, 0, 0, + 0, 1626, 1635, 1, 0, 0, 0, 1627, 1628, 10, 3, 0, 0, 1628, 1629, 5, 42, + 0, 0, 1629, 1634, 3, 80, 40, 4, 1630, 1631, 10, 2, 0, 0, 1631, 1632, 5, + 25, 0, 0, 1632, 1634, 3, 80, 40, 3, 1633, 1627, 1, 0, 0, 0, 1633, 1630, + 1, 0, 0, 0, 1634, 1637, 1, 0, 0, 0, 1635, 1633, 1, 0, 0, 0, 1635, 1636, + 1, 0, 0, 0, 1636, 81, 1, 0, 0, 0, 1637, 1635, 1, 0, 0, 0, 1638, 1642, 3, + 1200, 600, 0, 1639, 1642, 5, 16, 0, 0, 1640, 1642, 3, 84, 42, 0, 1641, + 1638, 1, 0, 0, 0, 1641, 1639, 1, 0, 0, 0, 1641, 1640, 1, 0, 0, 0, 1642, + 83, 1, 0, 0, 0, 1643, 1644, 5, 21, 0, 0, 1644, 1645, 3, 80, 40, 0, 1645, + 1646, 5, 22, 0, 0, 1646, 85, 1, 0, 0, 0, 1647, 1648, 3, 98, 49, 0, 1648, + 87, 1, 0, 0, 0, 1649, 1651, 3, 92, 46, 0, 1650, 1652, 3, 90, 45, 0, 1651, + 1650, 1, 0, 0, 0, 1651, 1652, 1, 0, 0, 0, 1652, 89, 1, 0, 0, 0, 1653, 1654, + 7, 0, 0, 0, 1654, 91, 1, 0, 0, 0, 1655, 1656, 7, 1, 0, 0, 1656, 93, 1, + 0, 0, 0, 1657, 1659, 7, 2, 0, 0, 1658, 1660, 5, 356, 0, 0, 1659, 1658, + 1, 0, 0, 0, 1659, 1660, 1, 0, 0, 0, 1660, 95, 1, 0, 0, 0, 1661, 1662, 3, + 98, 49, 0, 1662, 1663, 5, 1, 0, 0, 1663, 97, 1, 0, 0, 0, 1664, 1667, 3, + 1206, 603, 0, 1665, 1667, 3, 1204, 602, 0, 1666, 1664, 1, 0, 0, 0, 1666, + 1665, 1, 0, 0, 0, 1667, 99, 1, 0, 0, 0, 1668, 1670, 5, 246, 0, 0, 1669, + 1671, 3, 1066, 533, 0, 1670, 1669, 1, 0, 0, 0, 1670, 1671, 1, 0, 0, 0, + 1671, 1673, 1, 0, 0, 0, 1672, 1674, 3, 734, 367, 0, 1673, 1672, 1, 0, 0, + 0, 1673, 1674, 1, 0, 0, 0, 1674, 1675, 1, 0, 0, 0, 1675, 1677, 3, 110, + 55, 0, 1676, 1678, 3, 778, 389, 0, 1677, 1676, 1, 0, 0, 0, 1677, 1678, + 1, 0, 0, 0, 1678, 1680, 1, 0, 0, 0, 1679, 1681, 3, 104, 52, 0, 1680, 1679, + 1, 0, 0, 0, 1680, 1681, 1, 0, 0, 0, 1681, 1683, 1, 0, 0, 0, 1682, 1684, + 3, 102, 51, 0, 1683, 1682, 1, 0, 0, 0, 1683, 1684, 1, 0, 0, 0, 1684, 101, + 1, 0, 0, 0, 1685, 1686, 5, 83, 0, 0, 1686, 1687, 3, 808, 404, 0, 1687, + 1688, 5, 78, 0, 0, 1688, 1689, 3, 808, 404, 0, 1689, 1702, 1, 0, 0, 0, + 1690, 1691, 5, 355, 0, 0, 1691, 1692, 3, 808, 404, 0, 1692, 1693, 5, 78, + 0, 0, 1693, 1694, 3, 808, 404, 0, 1694, 1702, 1, 0, 0, 0, 1695, 1696, 5, + 83, 0, 0, 1696, 1702, 3, 808, 404, 0, 1697, 1698, 5, 355, 0, 0, 1698, 1702, + 3, 808, 404, 0, 1699, 1700, 5, 78, 0, 0, 1700, 1702, 3, 808, 404, 0, 1701, + 1685, 1, 0, 0, 0, 1701, 1690, 1, 0, 0, 0, 1701, 1695, 1, 0, 0, 0, 1701, + 1697, 1, 0, 0, 0, 1701, 1699, 1, 0, 0, 0, 1702, 103, 1, 0, 0, 0, 1703, + 1705, 5, 86, 0, 0, 1704, 1706, 3, 1066, 533, 0, 1705, 1704, 1, 0, 0, 0, + 1705, 1706, 1, 0, 0, 0, 1706, 1707, 1, 0, 0, 0, 1707, 1708, 5, 60, 0, 0, + 1708, 1713, 3, 106, 53, 0, 1709, 1710, 5, 17, 0, 0, 1710, 1712, 3, 106, + 53, 0, 1711, 1709, 1, 0, 0, 0, 1712, 1715, 1, 0, 0, 0, 1713, 1711, 1, 0, + 0, 0, 1713, 1714, 1, 0, 0, 0, 1714, 105, 1, 0, 0, 0, 1715, 1713, 1, 0, + 0, 0, 1716, 1718, 3, 952, 476, 0, 1717, 1719, 3, 1172, 586, 0, 1718, 1717, + 1, 0, 0, 0, 1718, 1719, 1, 0, 0, 0, 1719, 1721, 1, 0, 0, 0, 1720, 1722, + 3, 108, 54, 0, 1721, 1720, 1, 0, 0, 0, 1721, 1722, 1, 0, 0, 0, 1722, 1724, + 1, 0, 0, 0, 1723, 1725, 3, 1096, 548, 0, 1724, 1723, 1, 0, 0, 0, 1724, + 1725, 1, 0, 0, 0, 1725, 107, 1, 0, 0, 0, 1726, 1730, 3, 1094, 547, 0, 1727, + 1730, 5, 353, 0, 0, 1728, 1730, 5, 354, 0, 0, 1729, 1726, 1, 0, 0, 0, 1729, + 1727, 1, 0, 0, 0, 1729, 1728, 1, 0, 0, 0, 1730, 109, 1, 0, 0, 0, 1731, + 1736, 3, 112, 56, 0, 1732, 1733, 5, 17, 0, 0, 1733, 1735, 3, 112, 56, 0, + 1734, 1732, 1, 0, 0, 0, 1735, 1738, 1, 0, 0, 0, 1736, 1734, 1, 0, 0, 0, + 1736, 1737, 1, 0, 0, 0, 1737, 111, 1, 0, 0, 0, 1738, 1736, 1, 0, 0, 0, + 1739, 1742, 3, 952, 476, 0, 1740, 1741, 5, 58, 0, 0, 1741, 1743, 3, 1200, + 600, 0, 1742, 1740, 1, 0, 0, 0, 1742, 1743, 1, 0, 0, 0, 1743, 1746, 1, + 0, 0, 0, 1744, 1746, 5, 12, 0, 0, 1745, 1739, 1, 0, 0, 0, 1745, 1744, 1, + 0, 0, 0, 1746, 113, 1, 0, 0, 0, 1747, 1748, 5, 277, 0, 0, 1748, 1750, 3, + 584, 292, 0, 1749, 1751, 3, 670, 335, 0, 1750, 1749, 1, 0, 0, 0, 1750, + 1751, 1, 0, 0, 0, 1751, 1752, 1, 0, 0, 0, 1752, 1754, 3, 1198, 599, 0, + 1753, 1755, 3, 848, 424, 0, 1754, 1753, 1, 0, 0, 0, 1754, 1755, 1, 0, 0, + 0, 1755, 1757, 1, 0, 0, 0, 1756, 1758, 3, 696, 348, 0, 1757, 1756, 1, 0, + 0, 0, 1757, 1758, 1, 0, 0, 0, 1758, 115, 1, 0, 0, 0, 1759, 1760, 5, 216, + 0, 0, 1760, 1762, 3, 1198, 599, 0, 1761, 1763, 3, 696, 348, 0, 1762, 1761, + 1, 0, 0, 0, 1762, 1763, 1, 0, 0, 0, 1763, 117, 1, 0, 0, 0, 1764, 1765, + 5, 186, 0, 0, 1765, 1766, 3, 124, 62, 0, 1766, 1768, 3, 122, 61, 0, 1767, + 1769, 3, 120, 60, 0, 1768, 1767, 1, 0, 0, 0, 1768, 1769, 1, 0, 0, 0, 1769, + 1771, 1, 0, 0, 0, 1770, 1772, 3, 696, 348, 0, 1771, 1770, 1, 0, 0, 0, 1771, + 1772, 1, 0, 0, 0, 1772, 119, 1, 0, 0, 0, 1773, 1774, 7, 3, 0, 0, 1774, + 1775, 3, 1200, 600, 0, 1775, 121, 1, 0, 0, 0, 1776, 1779, 3, 1198, 599, + 0, 1777, 1779, 3, 1244, 622, 0, 1778, 1776, 1, 0, 0, 0, 1778, 1777, 1, + 0, 0, 0, 1779, 123, 1, 0, 0, 0, 1780, 1781, 7, 4, 0, 0, 1781, 125, 1, 0, + 0, 0, 1782, 1783, 5, 136, 0, 0, 1783, 1784, 3, 1198, 599, 0, 1784, 1793, + 5, 21, 0, 0, 1785, 1790, 3, 882, 441, 0, 1786, 1787, 5, 17, 0, 0, 1787, + 1789, 3, 882, 441, 0, 1788, 1786, 1, 0, 0, 0, 1789, 1792, 1, 0, 0, 0, 1790, + 1788, 1, 0, 0, 0, 1790, 1791, 1, 0, 0, 0, 1791, 1794, 1, 0, 0, 0, 1792, + 1790, 1, 0, 0, 0, 1793, 1785, 1, 0, 0, 0, 1793, 1794, 1, 0, 0, 0, 1794, + 1795, 1, 0, 0, 0, 1795, 1796, 5, 22, 0, 0, 1796, 127, 1, 0, 0, 0, 1797, + 1798, 5, 162, 0, 0, 1798, 1799, 5, 227, 0, 0, 1799, 1801, 5, 244, 0, 0, + 1800, 1802, 3, 702, 351, 0, 1801, 1800, 1, 0, 0, 0, 1801, 1802, 1, 0, 0, + 0, 1802, 1803, 1, 0, 0, 0, 1803, 1804, 5, 84, 0, 0, 1804, 1805, 3, 572, + 286, 0, 1805, 1806, 5, 84, 0, 0, 1806, 1807, 3, 1200, 600, 0, 1807, 1808, + 3, 1198, 599, 0, 1808, 1865, 1, 0, 0, 0, 1809, 1810, 5, 162, 0, 0, 1810, + 1811, 5, 249, 0, 0, 1811, 1812, 5, 123, 0, 0, 1812, 1814, 5, 224, 0, 0, + 1813, 1815, 3, 702, 351, 0, 1814, 1813, 1, 0, 0, 0, 1814, 1815, 1, 0, 0, + 0, 1815, 1816, 1, 0, 0, 0, 1816, 1817, 3, 1200, 600, 0, 1817, 1818, 3, + 306, 153, 0, 1818, 1865, 1, 0, 0, 0, 1819, 1820, 5, 162, 0, 0, 1820, 1821, + 3, 308, 154, 0, 1821, 1823, 5, 188, 0, 0, 1822, 1824, 3, 702, 351, 0, 1823, + 1822, 1, 0, 0, 0, 1823, 1824, 1, 0, 0, 0, 1824, 1825, 1, 0, 0, 0, 1825, + 1827, 3, 1198, 599, 0, 1826, 1828, 3, 306, 153, 0, 1827, 1826, 1, 0, 0, + 0, 1827, 1828, 1, 0, 0, 0, 1828, 1865, 1, 0, 0, 0, 1829, 1830, 5, 162, + 0, 0, 1830, 1832, 3, 704, 352, 0, 1831, 1833, 3, 702, 351, 0, 1832, 1831, + 1, 0, 0, 0, 1832, 1833, 1, 0, 0, 0, 1833, 1834, 1, 0, 0, 0, 1834, 1836, + 3, 858, 429, 0, 1835, 1837, 3, 212, 106, 0, 1836, 1835, 1, 0, 0, 0, 1836, + 1837, 1, 0, 0, 0, 1837, 1865, 1, 0, 0, 0, 1838, 1839, 5, 162, 0, 0, 1839, + 1840, 5, 259, 0, 0, 1840, 1842, 5, 268, 0, 0, 1841, 1843, 3, 702, 351, + 0, 1842, 1841, 1, 0, 0, 0, 1842, 1843, 1, 0, 0, 0, 1843, 1844, 1, 0, 0, + 0, 1844, 1865, 3, 858, 429, 0, 1845, 1846, 5, 162, 0, 0, 1846, 1848, 3, + 580, 290, 0, 1847, 1849, 3, 702, 351, 0, 1848, 1847, 1, 0, 0, 0, 1848, + 1849, 1, 0, 0, 0, 1849, 1850, 1, 0, 0, 0, 1850, 1851, 3, 1198, 599, 0, + 1851, 1865, 1, 0, 0, 0, 1852, 1853, 5, 162, 0, 0, 1853, 1855, 3, 584, 292, + 0, 1854, 1856, 3, 702, 351, 0, 1855, 1854, 1, 0, 0, 0, 1855, 1856, 1, 0, + 0, 0, 1856, 1857, 1, 0, 0, 0, 1857, 1859, 3, 1198, 599, 0, 1858, 1860, + 3, 212, 106, 0, 1859, 1858, 1, 0, 0, 0, 1859, 1860, 1, 0, 0, 0, 1860, 1862, + 1, 0, 0, 0, 1861, 1863, 3, 130, 65, 0, 1862, 1861, 1, 0, 0, 0, 1862, 1863, + 1, 0, 0, 0, 1863, 1865, 1, 0, 0, 0, 1864, 1797, 1, 0, 0, 0, 1864, 1809, + 1, 0, 0, 0, 1864, 1819, 1, 0, 0, 0, 1864, 1829, 1, 0, 0, 0, 1864, 1838, + 1, 0, 0, 0, 1864, 1845, 1, 0, 0, 0, 1864, 1852, 1, 0, 0, 0, 1865, 129, + 1, 0, 0, 0, 1866, 1867, 7, 5, 0, 0, 1867, 131, 1, 0, 0, 0, 1868, 1869, + 5, 162, 0, 0, 1869, 1870, 5, 57, 0, 0, 1870, 1872, 5, 249, 0, 0, 1871, + 1873, 5, 123, 0, 0, 1872, 1871, 1, 0, 0, 0, 1872, 1873, 1, 0, 0, 0, 1873, + 1874, 1, 0, 0, 0, 1874, 1875, 5, 223, 0, 0, 1875, 1876, 5, 84, 0, 0, 1876, + 1877, 3, 1198, 599, 0, 1877, 133, 1, 0, 0, 0, 1878, 1879, 5, 258, 0, 0, + 1879, 1881, 3, 138, 69, 0, 1880, 1882, 3, 172, 86, 0, 1881, 1880, 1, 0, + 0, 0, 1881, 1882, 1, 0, 0, 0, 1882, 1884, 1, 0, 0, 0, 1883, 1885, 3, 136, + 68, 0, 1884, 1883, 1, 0, 0, 0, 1884, 1885, 1, 0, 0, 0, 1885, 135, 1, 0, + 0, 0, 1886, 1887, 5, 335, 0, 0, 1887, 1888, 3, 1244, 622, 0, 1888, 137, + 1, 0, 0, 0, 1889, 1890, 5, 207, 0, 0, 1890, 1893, 5, 285, 0, 0, 1891, 1893, + 3, 1200, 600, 0, 1892, 1889, 1, 0, 0, 0, 1892, 1891, 1, 0, 0, 0, 1893, + 139, 1, 0, 0, 0, 1894, 1895, 5, 237, 0, 0, 1895, 1896, 3, 1200, 600, 0, + 1896, 1897, 3, 1198, 599, 0, 1897, 1898, 5, 331, 0, 0, 1898, 1899, 3, 1198, + 599, 0, 1899, 141, 1, 0, 0, 0, 1900, 1901, 5, 247, 0, 0, 1901, 1902, 3, + 146, 73, 0, 1902, 1907, 5, 84, 0, 0, 1903, 1905, 3, 1200, 600, 0, 1904, + 1906, 3, 1200, 600, 0, 1905, 1904, 1, 0, 0, 0, 1905, 1906, 1, 0, 0, 0, + 1906, 1908, 1, 0, 0, 0, 1907, 1903, 1, 0, 0, 0, 1907, 1908, 1, 0, 0, 0, + 1908, 1909, 1, 0, 0, 0, 1909, 1910, 3, 1198, 599, 0, 1910, 1911, 5, 71, + 0, 0, 1911, 1912, 3, 570, 285, 0, 1912, 143, 1, 0, 0, 0, 1913, 1914, 5, + 180, 0, 0, 1914, 1915, 3, 146, 73, 0, 1915, 1920, 5, 84, 0, 0, 1916, 1918, + 3, 1200, 600, 0, 1917, 1919, 3, 1200, 600, 0, 1918, 1917, 1, 0, 0, 0, 1918, + 1919, 1, 0, 0, 0, 1919, 1921, 1, 0, 0, 0, 1920, 1916, 1, 0, 0, 0, 1920, + 1921, 1, 0, 0, 0, 1921, 1922, 1, 0, 0, 0, 1922, 1923, 3, 1198, 599, 0, + 1923, 1924, 5, 331, 0, 0, 1924, 1925, 3, 570, 285, 0, 1925, 145, 1, 0, + 0, 0, 1926, 1928, 5, 57, 0, 0, 1927, 1929, 5, 228, 0, 0, 1928, 1927, 1, + 0, 0, 0, 1928, 1929, 1, 0, 0, 0, 1929, 1932, 1, 0, 0, 0, 1930, 1932, 3, + 572, 286, 0, 1931, 1926, 1, 0, 0, 0, 1931, 1930, 1, 0, 0, 0, 1932, 147, + 1, 0, 0, 0, 1933, 1934, 5, 169, 0, 0, 1934, 1935, 3, 704, 352, 0, 1935, + 1936, 5, 212, 0, 0, 1936, 1937, 5, 71, 0, 0, 1937, 1939, 3, 858, 429, 0, + 1938, 1940, 3, 396, 198, 0, 1939, 1938, 1, 0, 0, 0, 1939, 1940, 1, 0, 0, + 0, 1940, 1942, 1, 0, 0, 0, 1941, 1943, 3, 696, 348, 0, 1942, 1941, 1, 0, + 0, 0, 1942, 1943, 1, 0, 0, 0, 1943, 149, 1, 0, 0, 0, 1944, 1945, 5, 169, + 0, 0, 1945, 1946, 5, 215, 0, 0, 1946, 1948, 3, 1198, 599, 0, 1947, 1949, + 3, 396, 198, 0, 1948, 1947, 1, 0, 0, 0, 1948, 1949, 1, 0, 0, 0, 1949, 1951, + 1, 0, 0, 0, 1950, 1952, 3, 696, 348, 0, 1951, 1950, 1, 0, 0, 0, 1951, 1952, + 1, 0, 0, 0, 1952, 151, 1, 0, 0, 0, 1953, 1954, 3, 154, 77, 0, 1954, 1955, + 3, 260, 130, 0, 1955, 153, 1, 0, 0, 0, 1956, 1957, 5, 169, 0, 0, 1957, + 1959, 5, 152, 0, 0, 1958, 1960, 3, 396, 198, 0, 1959, 1958, 1, 0, 0, 0, + 1959, 1960, 1, 0, 0, 0, 1960, 1962, 1, 0, 0, 0, 1961, 1963, 3, 696, 348, + 0, 1962, 1961, 1, 0, 0, 0, 1962, 1963, 1, 0, 0, 0, 1963, 155, 1, 0, 0, + 0, 1964, 1965, 5, 168, 0, 0, 1965, 1966, 3, 4, 2, 0, 1966, 157, 1, 0, 0, + 0, 1967, 1968, 5, 167, 0, 0, 1968, 1969, 5, 184, 0, 0, 1969, 1971, 3, 952, + 476, 0, 1970, 1972, 3, 160, 80, 0, 1971, 1970, 1, 0, 0, 0, 1971, 1972, + 1, 0, 0, 0, 1972, 1974, 1, 0, 0, 0, 1973, 1975, 3, 162, 81, 0, 1974, 1973, + 1, 0, 0, 0, 1974, 1975, 1, 0, 0, 0, 1975, 159, 1, 0, 0, 0, 1976, 1977, + 5, 338, 0, 0, 1977, 1978, 3, 446, 223, 0, 1978, 161, 1, 0, 0, 0, 1979, + 1980, 5, 102, 0, 0, 1980, 1981, 3, 164, 82, 0, 1981, 163, 1, 0, 0, 0, 1982, + 1987, 3, 166, 83, 0, 1983, 1984, 5, 17, 0, 0, 1984, 1986, 3, 166, 83, 0, + 1985, 1983, 1, 0, 0, 0, 1986, 1989, 1, 0, 0, 0, 1987, 1985, 1, 0, 0, 0, + 1987, 1988, 1, 0, 0, 0, 1988, 165, 1, 0, 0, 0, 1989, 1987, 1, 0, 0, 0, + 1990, 1993, 3, 952, 476, 0, 1991, 1992, 5, 58, 0, 0, 1992, 1994, 3, 1200, + 600, 0, 1993, 1991, 1, 0, 0, 0, 1993, 1994, 1, 0, 0, 0, 1994, 167, 1, 0, + 0, 0, 1995, 1996, 3, 174, 87, 0, 1996, 1997, 3, 170, 85, 0, 1997, 169, + 1, 0, 0, 0, 1998, 2000, 3, 1200, 600, 0, 1999, 1998, 1, 0, 0, 0, 1999, + 2000, 1, 0, 0, 0, 2000, 2001, 1, 0, 0, 0, 2001, 2003, 3, 856, 428, 0, 2002, + 2004, 3, 172, 86, 0, 2003, 2002, 1, 0, 0, 0, 2003, 2004, 1, 0, 0, 0, 2004, + 171, 1, 0, 0, 0, 2005, 2006, 5, 71, 0, 0, 2006, 2007, 3, 856, 428, 0, 2007, + 173, 1, 0, 0, 0, 2008, 2009, 7, 6, 0, 0, 2009, 175, 1, 0, 0, 0, 2010, 2011, + 5, 327, 0, 0, 2011, 2012, 5, 268, 0, 0, 2012, 2014, 3, 1198, 599, 0, 2013, + 2015, 3, 1034, 517, 0, 2014, 2013, 1, 0, 0, 0, 2014, 2015, 1, 0, 0, 0, + 2015, 177, 1, 0, 0, 0, 2016, 2018, 5, 343, 0, 0, 2017, 2019, 3, 430, 215, + 0, 2018, 2017, 1, 0, 0, 0, 2018, 2019, 1, 0, 0, 0, 2019, 2020, 1, 0, 0, + 0, 2020, 2022, 3, 580, 290, 0, 2021, 2023, 3, 670, 335, 0, 2022, 2021, + 1, 0, 0, 0, 2022, 2023, 1, 0, 0, 0, 2023, 2024, 1, 0, 0, 0, 2024, 2026, + 3, 1198, 599, 0, 2025, 2027, 3, 696, 348, 0, 2026, 2025, 1, 0, 0, 0, 2026, + 2027, 1, 0, 0, 0, 2027, 2029, 1, 0, 0, 0, 2028, 2030, 3, 180, 90, 0, 2029, + 2028, 1, 0, 0, 0, 2029, 2030, 1, 0, 0, 0, 2030, 179, 1, 0, 0, 0, 2031, + 2032, 5, 58, 0, 0, 2032, 2033, 3, 700, 350, 0, 2033, 181, 1, 0, 0, 0, 2034, + 2036, 5, 343, 0, 0, 2035, 2037, 3, 430, 215, 0, 2036, 2035, 1, 0, 0, 0, + 2036, 2037, 1, 0, 0, 0, 2037, 2039, 1, 0, 0, 0, 2038, 2040, 3, 432, 216, + 0, 2039, 2038, 1, 0, 0, 0, 2039, 2040, 1, 0, 0, 0, 2040, 2042, 1, 0, 0, + 0, 2041, 2043, 5, 92, 0, 0, 2042, 2041, 1, 0, 0, 0, 2042, 2043, 1, 0, 0, + 0, 2043, 2044, 1, 0, 0, 0, 2044, 2046, 5, 284, 0, 0, 2045, 2047, 3, 670, + 335, 0, 2046, 2045, 1, 0, 0, 0, 2046, 2047, 1, 0, 0, 0, 2047, 2048, 1, + 0, 0, 0, 2048, 2050, 3, 858, 429, 0, 2049, 2051, 3, 186, 93, 0, 2050, 2049, + 1, 0, 0, 0, 2050, 2051, 1, 0, 0, 0, 2051, 2053, 1, 0, 0, 0, 2052, 2054, + 3, 380, 190, 0, 2053, 2052, 1, 0, 0, 0, 2053, 2054, 1, 0, 0, 0, 2054, 2056, + 1, 0, 0, 0, 2055, 2057, 3, 696, 348, 0, 2056, 2055, 1, 0, 0, 0, 2056, 2057, + 1, 0, 0, 0, 2057, 2058, 1, 0, 0, 0, 2058, 2059, 3, 260, 130, 0, 2059, 2116, + 1, 0, 0, 0, 2060, 2062, 5, 343, 0, 0, 2061, 2063, 3, 430, 215, 0, 2062, + 2061, 1, 0, 0, 0, 2062, 2063, 1, 0, 0, 0, 2063, 2064, 1, 0, 0, 0, 2064, + 2066, 5, 207, 0, 0, 2065, 2067, 5, 92, 0, 0, 2066, 2065, 1, 0, 0, 0, 2066, + 2067, 1, 0, 0, 0, 2067, 2068, 1, 0, 0, 0, 2068, 2070, 5, 284, 0, 0, 2069, + 2071, 3, 670, 335, 0, 2070, 2069, 1, 0, 0, 0, 2070, 2071, 1, 0, 0, 0, 2071, + 2072, 1, 0, 0, 0, 2072, 2074, 3, 858, 429, 0, 2073, 2075, 3, 186, 93, 0, + 2074, 2073, 1, 0, 0, 0, 2074, 2075, 1, 0, 0, 0, 2075, 2077, 1, 0, 0, 0, + 2076, 2078, 3, 380, 190, 0, 2077, 2076, 1, 0, 0, 0, 2077, 2078, 1, 0, 0, + 0, 2078, 2080, 1, 0, 0, 0, 2079, 2081, 3, 818, 409, 0, 2080, 2079, 1, 0, + 0, 0, 2080, 2081, 1, 0, 0, 0, 2081, 2083, 1, 0, 0, 0, 2082, 2084, 3, 544, + 272, 0, 2083, 2082, 1, 0, 0, 0, 2083, 2084, 1, 0, 0, 0, 2084, 2086, 1, + 0, 0, 0, 2085, 2087, 3, 696, 348, 0, 2086, 2085, 1, 0, 0, 0, 2086, 2087, + 1, 0, 0, 0, 2087, 2088, 1, 0, 0, 0, 2088, 2089, 5, 58, 0, 0, 2089, 2090, + 3, 184, 92, 0, 2090, 2116, 1, 0, 0, 0, 2091, 2093, 5, 343, 0, 0, 2092, + 2094, 3, 430, 215, 0, 2093, 2092, 1, 0, 0, 0, 2093, 2094, 1, 0, 0, 0, 2094, + 2095, 1, 0, 0, 0, 2095, 2097, 5, 130, 0, 0, 2096, 2098, 5, 92, 0, 0, 2097, + 2096, 1, 0, 0, 0, 2097, 2098, 1, 0, 0, 0, 2098, 2099, 1, 0, 0, 0, 2099, + 2101, 5, 284, 0, 0, 2100, 2102, 3, 670, 335, 0, 2101, 2100, 1, 0, 0, 0, + 2101, 2102, 1, 0, 0, 0, 2102, 2103, 1, 0, 0, 0, 2103, 2105, 3, 858, 429, + 0, 2104, 2106, 3, 186, 93, 0, 2105, 2104, 1, 0, 0, 0, 2105, 2106, 1, 0, + 0, 0, 2106, 2108, 1, 0, 0, 0, 2107, 2109, 3, 380, 190, 0, 2108, 2107, 1, + 0, 0, 0, 2108, 2109, 1, 0, 0, 0, 2109, 2111, 1, 0, 0, 0, 2110, 2112, 3, + 696, 348, 0, 2111, 2110, 1, 0, 0, 0, 2111, 2112, 1, 0, 0, 0, 2112, 2113, + 1, 0, 0, 0, 2113, 2114, 3, 260, 130, 0, 2114, 2116, 1, 0, 0, 0, 2115, 2034, + 1, 0, 0, 0, 2115, 2060, 1, 0, 0, 0, 2115, 2091, 1, 0, 0, 0, 2116, 183, + 1, 0, 0, 0, 2117, 2122, 3, 706, 353, 0, 2118, 2119, 5, 241, 0, 0, 2119, + 2120, 5, 82, 0, 0, 2120, 2122, 3, 858, 429, 0, 2121, 2117, 1, 0, 0, 0, + 2121, 2118, 1, 0, 0, 0, 2122, 185, 1, 0, 0, 0, 2123, 2124, 5, 21, 0, 0, + 2124, 2129, 3, 188, 94, 0, 2125, 2126, 5, 17, 0, 0, 2126, 2128, 3, 188, + 94, 0, 2127, 2125, 1, 0, 0, 0, 2128, 2131, 1, 0, 0, 0, 2129, 2127, 1, 0, + 0, 0, 2129, 2130, 1, 0, 0, 0, 2130, 2132, 1, 0, 0, 0, 2131, 2129, 1, 0, + 0, 0, 2132, 2133, 5, 22, 0, 0, 2133, 187, 1, 0, 0, 0, 2134, 2136, 3, 1200, + 600, 0, 2135, 2137, 3, 696, 348, 0, 2136, 2135, 1, 0, 0, 0, 2136, 2137, + 1, 0, 0, 0, 2137, 189, 1, 0, 0, 0, 2138, 2140, 5, 343, 0, 0, 2139, 2141, + 3, 430, 215, 0, 2140, 2139, 1, 0, 0, 0, 2140, 2141, 1, 0, 0, 0, 2141, 2143, + 1, 0, 0, 0, 2142, 2144, 3, 432, 216, 0, 2143, 2142, 1, 0, 0, 0, 2143, 2144, + 1, 0, 0, 0, 2144, 2145, 1, 0, 0, 0, 2145, 2147, 5, 268, 0, 0, 2146, 2148, + 3, 670, 335, 0, 2147, 2146, 1, 0, 0, 0, 2147, 2148, 1, 0, 0, 0, 2148, 2149, + 1, 0, 0, 0, 2149, 2151, 3, 858, 429, 0, 2150, 2152, 3, 550, 275, 0, 2151, + 2150, 1, 0, 0, 0, 2151, 2152, 1, 0, 0, 0, 2152, 2154, 1, 0, 0, 0, 2153, + 2155, 3, 200, 100, 0, 2154, 2153, 1, 0, 0, 0, 2154, 2155, 1, 0, 0, 0, 2155, + 2157, 1, 0, 0, 0, 2156, 2158, 3, 268, 134, 0, 2157, 2156, 1, 0, 0, 0, 2157, + 2158, 1, 0, 0, 0, 2158, 2160, 1, 0, 0, 0, 2159, 2161, 3, 198, 99, 0, 2160, + 2159, 1, 0, 0, 0, 2160, 2161, 1, 0, 0, 0, 2161, 2163, 1, 0, 0, 0, 2162, + 2164, 3, 194, 97, 0, 2163, 2162, 1, 0, 0, 0, 2163, 2164, 1, 0, 0, 0, 2164, + 2166, 1, 0, 0, 0, 2165, 2167, 3, 266, 133, 0, 2166, 2165, 1, 0, 0, 0, 2166, + 2167, 1, 0, 0, 0, 2167, 2169, 1, 0, 0, 0, 2168, 2170, 3, 818, 409, 0, 2169, + 2168, 1, 0, 0, 0, 2169, 2170, 1, 0, 0, 0, 2170, 2172, 1, 0, 0, 0, 2171, + 2173, 3, 544, 272, 0, 2172, 2171, 1, 0, 0, 0, 2172, 2173, 1, 0, 0, 0, 2173, + 2175, 1, 0, 0, 0, 2174, 2176, 3, 192, 96, 0, 2175, 2174, 1, 0, 0, 0, 2175, + 2176, 1, 0, 0, 0, 2176, 2178, 1, 0, 0, 0, 2177, 2179, 3, 396, 198, 0, 2178, + 2177, 1, 0, 0, 0, 2178, 2179, 1, 0, 0, 0, 2179, 2181, 1, 0, 0, 0, 2180, + 2182, 3, 696, 348, 0, 2181, 2180, 1, 0, 0, 0, 2181, 2182, 1, 0, 0, 0, 2182, + 2184, 1, 0, 0, 0, 2183, 2185, 3, 260, 130, 0, 2184, 2183, 1, 0, 0, 0, 2184, + 2185, 1, 0, 0, 0, 2185, 191, 1, 0, 0, 0, 2186, 2187, 5, 249, 0, 0, 2187, + 2188, 5, 157, 0, 0, 2188, 2189, 5, 224, 0, 0, 2189, 2190, 5, 21, 0, 0, + 2190, 2191, 3, 952, 476, 0, 2191, 2192, 5, 22, 0, 0, 2192, 193, 1, 0, 0, + 0, 2193, 2194, 5, 141, 0, 0, 2194, 2195, 3, 196, 98, 0, 2195, 195, 1, 0, + 0, 0, 2196, 2198, 3, 858, 429, 0, 2197, 2199, 3, 848, 424, 0, 2198, 2197, + 1, 0, 0, 0, 2198, 2199, 1, 0, 0, 0, 2199, 2201, 1, 0, 0, 0, 2200, 2202, + 3, 774, 387, 0, 2201, 2200, 1, 0, 0, 0, 2201, 2202, 1, 0, 0, 0, 2202, 197, + 1, 0, 0, 0, 2203, 2204, 5, 140, 0, 0, 2204, 2205, 3, 536, 268, 0, 2205, + 199, 1, 0, 0, 0, 2206, 2208, 3, 204, 102, 0, 2207, 2209, 3, 202, 101, 0, + 2208, 2207, 1, 0, 0, 0, 2208, 2209, 1, 0, 0, 0, 2209, 201, 1, 0, 0, 0, + 2210, 2211, 5, 17, 0, 0, 2211, 2212, 5, 292, 0, 0, 2212, 2213, 5, 73, 0, + 0, 2213, 2214, 5, 294, 0, 0, 2214, 2215, 3, 858, 429, 0, 2215, 2216, 3, + 686, 343, 0, 2216, 203, 1, 0, 0, 0, 2217, 2218, 5, 225, 0, 0, 2218, 2219, + 5, 195, 0, 0, 2219, 2220, 3, 674, 337, 0, 2220, 205, 1, 0, 0, 0, 2221, + 2223, 5, 343, 0, 0, 2222, 2224, 3, 430, 215, 0, 2223, 2222, 1, 0, 0, 0, + 2223, 2224, 1, 0, 0, 0, 2224, 2226, 1, 0, 0, 0, 2225, 2227, 3, 432, 216, + 0, 2226, 2225, 1, 0, 0, 0, 2226, 2227, 1, 0, 0, 0, 2227, 2228, 1, 0, 0, + 0, 2228, 2229, 5, 268, 0, 0, 2229, 2231, 5, 178, 0, 0, 2230, 2232, 3, 670, + 335, 0, 2231, 2230, 1, 0, 0, 0, 2231, 2232, 1, 0, 0, 0, 2232, 2233, 1, + 0, 0, 0, 2233, 2235, 3, 1198, 599, 0, 2234, 2236, 3, 212, 106, 0, 2235, + 2234, 1, 0, 0, 0, 2235, 2236, 1, 0, 0, 0, 2236, 2238, 1, 0, 0, 0, 2237, + 2239, 3, 400, 200, 0, 2238, 2237, 1, 0, 0, 0, 2238, 2239, 1, 0, 0, 0, 2239, + 2241, 1, 0, 0, 0, 2240, 2242, 3, 380, 190, 0, 2241, 2240, 1, 0, 0, 0, 2241, + 2242, 1, 0, 0, 0, 2242, 2244, 1, 0, 0, 0, 2243, 2245, 3, 210, 105, 0, 2244, + 2243, 1, 0, 0, 0, 2244, 2245, 1, 0, 0, 0, 2245, 2247, 1, 0, 0, 0, 2246, + 2248, 3, 208, 104, 0, 2247, 2246, 1, 0, 0, 0, 2247, 2248, 1, 0, 0, 0, 2248, + 2249, 1, 0, 0, 0, 2249, 2250, 6, 103, -1, 0, 2250, 207, 1, 0, 0, 0, 2251, + 2255, 3, 260, 130, 0, 2252, 2253, 5, 58, 0, 0, 2253, 2255, 3, 1244, 622, + 0, 2254, 2251, 1, 0, 0, 0, 2254, 2252, 1, 0, 0, 0, 2255, 209, 1, 0, 0, + 0, 2256, 2258, 3, 392, 196, 0, 2257, 2259, 3, 696, 348, 0, 2258, 2257, + 1, 0, 0, 0, 2258, 2259, 1, 0, 0, 0, 2259, 2265, 1, 0, 0, 0, 2260, 2262, + 3, 696, 348, 0, 2261, 2263, 3, 392, 196, 0, 2262, 2261, 1, 0, 0, 0, 2262, + 2263, 1, 0, 0, 0, 2263, 2265, 1, 0, 0, 0, 2264, 2256, 1, 0, 0, 0, 2264, + 2260, 1, 0, 0, 0, 2265, 211, 1, 0, 0, 0, 2266, 2275, 5, 21, 0, 0, 2267, + 2272, 3, 406, 203, 0, 2268, 2269, 5, 17, 0, 0, 2269, 2271, 3, 406, 203, + 0, 2270, 2268, 1, 0, 0, 0, 2271, 2274, 1, 0, 0, 0, 2272, 2270, 1, 0, 0, + 0, 2272, 2273, 1, 0, 0, 0, 2273, 2276, 1, 0, 0, 0, 2274, 2272, 1, 0, 0, + 0, 2275, 2267, 1, 0, 0, 0, 2275, 2276, 1, 0, 0, 0, 2276, 2277, 1, 0, 0, + 0, 2277, 2278, 5, 22, 0, 0, 2278, 213, 1, 0, 0, 0, 2279, 2281, 5, 343, + 0, 0, 2280, 2282, 3, 430, 215, 0, 2281, 2280, 1, 0, 0, 0, 2281, 2282, 1, + 0, 0, 0, 2282, 2283, 1, 0, 0, 0, 2283, 2286, 5, 259, 0, 0, 2284, 2287, + 5, 268, 0, 0, 2285, 2287, 3, 584, 292, 0, 2286, 2284, 1, 0, 0, 0, 2286, + 2285, 1, 0, 0, 0, 2287, 2289, 1, 0, 0, 0, 2288, 2290, 3, 670, 335, 0, 2289, + 2288, 1, 0, 0, 0, 2289, 2290, 1, 0, 0, 0, 2290, 2291, 1, 0, 0, 0, 2291, + 2292, 3, 858, 429, 0, 2292, 2293, 5, 140, 0, 0, 2293, 2295, 3, 536, 268, + 0, 2294, 2296, 3, 696, 348, 0, 2295, 2294, 1, 0, 0, 0, 2295, 2296, 1, 0, + 0, 0, 2296, 215, 1, 0, 0, 0, 2297, 2299, 5, 343, 0, 0, 2298, 2300, 3, 430, + 215, 0, 2299, 2298, 1, 0, 0, 0, 2299, 2300, 1, 0, 0, 0, 2300, 2302, 1, + 0, 0, 0, 2301, 2303, 3, 432, 216, 0, 2302, 2301, 1, 0, 0, 0, 2302, 2303, + 1, 0, 0, 0, 2303, 2304, 1, 0, 0, 0, 2304, 2305, 5, 171, 0, 0, 2305, 2307, + 5, 252, 0, 0, 2306, 2308, 3, 670, 335, 0, 2307, 2306, 1, 0, 0, 0, 2307, + 2308, 1, 0, 0, 0, 2308, 2309, 1, 0, 0, 0, 2309, 2311, 3, 1198, 599, 0, + 2310, 2312, 3, 396, 198, 0, 2311, 2310, 1, 0, 0, 0, 2311, 2312, 1, 0, 0, + 0, 2312, 2313, 1, 0, 0, 0, 2313, 2314, 3, 696, 348, 0, 2314, 217, 1, 0, + 0, 0, 2315, 2317, 5, 343, 0, 0, 2316, 2318, 3, 430, 215, 0, 2317, 2316, + 1, 0, 0, 0, 2317, 2318, 1, 0, 0, 0, 2318, 2319, 1, 0, 0, 0, 2319, 2321, + 5, 252, 0, 0, 2320, 2322, 3, 670, 335, 0, 2321, 2320, 1, 0, 0, 0, 2321, + 2322, 1, 0, 0, 0, 2322, 2323, 1, 0, 0, 0, 2323, 2325, 3, 1198, 599, 0, + 2324, 2326, 3, 266, 133, 0, 2325, 2324, 1, 0, 0, 0, 2325, 2326, 1, 0, 0, + 0, 2326, 2328, 1, 0, 0, 0, 2327, 2329, 3, 696, 348, 0, 2328, 2327, 1, 0, + 0, 0, 2328, 2329, 1, 0, 0, 0, 2329, 219, 1, 0, 0, 0, 2330, 2332, 5, 343, + 0, 0, 2331, 2333, 3, 430, 215, 0, 2332, 2331, 1, 0, 0, 0, 2332, 2333, 1, + 0, 0, 0, 2333, 2334, 1, 0, 0, 0, 2334, 2335, 5, 346, 0, 0, 2335, 2336, + 5, 347, 0, 0, 2336, 2337, 3, 670, 335, 0, 2337, 2339, 3, 1198, 599, 0, + 2338, 2340, 3, 696, 348, 0, 2339, 2338, 1, 0, 0, 0, 2339, 2340, 1, 0, 0, + 0, 2340, 2341, 1, 0, 0, 0, 2341, 2342, 5, 348, 0, 0, 2342, 2343, 5, 269, + 0, 0, 2343, 2345, 3, 224, 112, 0, 2344, 2346, 3, 222, 111, 0, 2345, 2344, + 1, 0, 0, 0, 2345, 2346, 1, 0, 0, 0, 2346, 221, 1, 0, 0, 0, 2347, 2348, + 5, 351, 0, 0, 2348, 2349, 5, 269, 0, 0, 2349, 2350, 3, 224, 112, 0, 2350, + 223, 1, 0, 0, 0, 2351, 2352, 5, 21, 0, 0, 2352, 2357, 3, 226, 113, 0, 2353, + 2354, 5, 17, 0, 0, 2354, 2356, 3, 226, 113, 0, 2355, 2353, 1, 0, 0, 0, + 2356, 2359, 1, 0, 0, 0, 2357, 2355, 1, 0, 0, 0, 2357, 2358, 1, 0, 0, 0, + 2358, 2361, 1, 0, 0, 0, 2359, 2357, 1, 0, 0, 0, 2360, 2362, 5, 17, 0, 0, + 2361, 2360, 1, 0, 0, 0, 2361, 2362, 1, 0, 0, 0, 2362, 2363, 1, 0, 0, 0, + 2363, 2364, 5, 22, 0, 0, 2364, 225, 1, 0, 0, 0, 2365, 2367, 3, 1198, 599, + 0, 2366, 2368, 3, 1088, 544, 0, 2367, 2366, 1, 0, 0, 0, 2367, 2368, 1, + 0, 0, 0, 2368, 2370, 1, 0, 0, 0, 2369, 2371, 3, 248, 124, 0, 2370, 2369, + 1, 0, 0, 0, 2370, 2371, 1, 0, 0, 0, 2371, 2373, 1, 0, 0, 0, 2372, 2374, + 3, 246, 123, 0, 2373, 2372, 1, 0, 0, 0, 2373, 2374, 1, 0, 0, 0, 2374, 2376, + 1, 0, 0, 0, 2375, 2377, 3, 244, 122, 0, 2376, 2375, 1, 0, 0, 0, 2376, 2377, + 1, 0, 0, 0, 2377, 2379, 1, 0, 0, 0, 2378, 2380, 3, 228, 114, 0, 2379, 2378, + 1, 0, 0, 0, 2379, 2380, 1, 0, 0, 0, 2380, 227, 1, 0, 0, 0, 2381, 2384, + 3, 234, 117, 0, 2382, 2384, 3, 230, 115, 0, 2383, 2381, 1, 0, 0, 0, 2383, + 2382, 1, 0, 0, 0, 2384, 229, 1, 0, 0, 0, 2385, 2387, 3, 232, 116, 0, 2386, + 2385, 1, 0, 0, 0, 2387, 2388, 1, 0, 0, 0, 2388, 2386, 1, 0, 0, 0, 2388, + 2389, 1, 0, 0, 0, 2389, 231, 1, 0, 0, 0, 2390, 2392, 5, 324, 0, 0, 2391, + 2390, 1, 0, 0, 0, 2391, 2392, 1, 0, 0, 0, 2392, 2393, 1, 0, 0, 0, 2393, + 2394, 5, 350, 0, 0, 2394, 2396, 3, 1200, 600, 0, 2395, 2397, 3, 234, 117, + 0, 2396, 2395, 1, 0, 0, 0, 2396, 2397, 1, 0, 0, 0, 2397, 233, 1, 0, 0, + 0, 2398, 2399, 5, 337, 0, 0, 2399, 2410, 5, 349, 0, 0, 2400, 2402, 3, 242, + 121, 0, 2401, 2403, 3, 240, 120, 0, 2402, 2401, 1, 0, 0, 0, 2402, 2403, + 1, 0, 0, 0, 2403, 2410, 1, 0, 0, 0, 2404, 2405, 5, 349, 0, 0, 2405, 2406, + 5, 21, 0, 0, 2406, 2407, 3, 236, 118, 0, 2407, 2408, 5, 22, 0, 0, 2408, + 2410, 1, 0, 0, 0, 2409, 2398, 1, 0, 0, 0, 2409, 2400, 1, 0, 0, 0, 2409, + 2404, 1, 0, 0, 0, 2410, 235, 1, 0, 0, 0, 2411, 2416, 3, 238, 119, 0, 2412, + 2413, 5, 17, 0, 0, 2413, 2415, 3, 238, 119, 0, 2414, 2412, 1, 0, 0, 0, + 2415, 2418, 1, 0, 0, 0, 2416, 2414, 1, 0, 0, 0, 2416, 2417, 1, 0, 0, 0, + 2417, 237, 1, 0, 0, 0, 2418, 2416, 1, 0, 0, 0, 2419, 2421, 3, 952, 476, + 0, 2420, 2422, 3, 1088, 544, 0, 2421, 2420, 1, 0, 0, 0, 2421, 2422, 1, + 0, 0, 0, 2422, 239, 1, 0, 0, 0, 2423, 2424, 5, 68, 0, 0, 2424, 2425, 3, + 694, 347, 0, 2425, 241, 1, 0, 0, 0, 2426, 2428, 5, 349, 0, 0, 2427, 2429, + 5, 131, 0, 0, 2428, 2427, 1, 0, 0, 0, 2428, 2429, 1, 0, 0, 0, 2429, 2430, + 1, 0, 0, 0, 2430, 2431, 5, 57, 0, 0, 2431, 2432, 5, 144, 0, 0, 2432, 243, + 1, 0, 0, 0, 2433, 2434, 5, 345, 0, 0, 2434, 2435, 5, 195, 0, 0, 2435, 2436, + 3, 694, 347, 0, 2436, 2437, 5, 234, 0, 0, 2437, 2439, 3, 1200, 600, 0, + 2438, 2440, 3, 694, 347, 0, 2439, 2438, 1, 0, 0, 0, 2439, 2440, 1, 0, 0, + 0, 2440, 245, 1, 0, 0, 0, 2441, 2442, 5, 260, 0, 0, 2442, 2443, 5, 195, + 0, 0, 2443, 2444, 3, 694, 347, 0, 2444, 2445, 5, 234, 0, 0, 2445, 2447, + 3, 1200, 600, 0, 2446, 2448, 3, 694, 347, 0, 2447, 2446, 1, 0, 0, 0, 2447, + 2448, 1, 0, 0, 0, 2448, 247, 1, 0, 0, 0, 2449, 2450, 5, 195, 0, 0, 2450, + 2451, 3, 694, 347, 0, 2451, 249, 1, 0, 0, 0, 2452, 2454, 5, 343, 0, 0, + 2453, 2455, 3, 430, 215, 0, 2454, 2453, 1, 0, 0, 0, 2454, 2455, 1, 0, 0, + 0, 2455, 2457, 1, 0, 0, 0, 2456, 2458, 3, 432, 216, 0, 2457, 2456, 1, 0, + 0, 0, 2457, 2458, 1, 0, 0, 0, 2458, 2459, 1, 0, 0, 0, 2459, 2461, 5, 215, + 0, 0, 2460, 2462, 3, 670, 335, 0, 2461, 2460, 1, 0, 0, 0, 2461, 2462, 1, + 0, 0, 0, 2462, 2463, 1, 0, 0, 0, 2463, 2465, 3, 1198, 599, 0, 2464, 2466, + 3, 252, 126, 0, 2465, 2464, 1, 0, 0, 0, 2465, 2466, 1, 0, 0, 0, 2466, 2468, + 1, 0, 0, 0, 2467, 2469, 3, 254, 127, 0, 2468, 2467, 1, 0, 0, 0, 2468, 2469, + 1, 0, 0, 0, 2469, 2471, 1, 0, 0, 0, 2470, 2472, 3, 394, 197, 0, 2471, 2470, + 1, 0, 0, 0, 2471, 2472, 1, 0, 0, 0, 2472, 2474, 1, 0, 0, 0, 2473, 2475, + 3, 696, 348, 0, 2474, 2473, 1, 0, 0, 0, 2474, 2475, 1, 0, 0, 0, 2475, 2477, + 1, 0, 0, 0, 2476, 2478, 3, 256, 128, 0, 2477, 2476, 1, 0, 0, 0, 2477, 2478, + 1, 0, 0, 0, 2478, 251, 1, 0, 0, 0, 2479, 2480, 5, 190, 0, 0, 2480, 2481, + 3, 550, 275, 0, 2481, 2482, 5, 219, 0, 0, 2482, 2483, 3, 550, 275, 0, 2483, + 253, 1, 0, 0, 0, 2484, 2485, 5, 274, 0, 0, 2485, 2486, 5, 21, 0, 0, 2486, + 2487, 3, 934, 467, 0, 2487, 2488, 5, 22, 0, 0, 2488, 255, 1, 0, 0, 0, 2489, + 2496, 3, 260, 130, 0, 2490, 2491, 5, 58, 0, 0, 2491, 2492, 5, 21, 0, 0, + 2492, 2493, 3, 258, 129, 0, 2493, 2494, 5, 22, 0, 0, 2494, 2496, 1, 0, + 0, 0, 2495, 2489, 1, 0, 0, 0, 2495, 2490, 1, 0, 0, 0, 2496, 257, 1, 0, + 0, 0, 2497, 2502, 3, 744, 372, 0, 2498, 2499, 5, 17, 0, 0, 2499, 2501, + 3, 744, 372, 0, 2500, 2498, 1, 0, 0, 0, 2501, 2504, 1, 0, 0, 0, 2502, 2500, + 1, 0, 0, 0, 2502, 2503, 1, 0, 0, 0, 2503, 259, 1, 0, 0, 0, 2504, 2502, + 1, 0, 0, 0, 2505, 2506, 5, 58, 0, 0, 2506, 2507, 3, 706, 353, 0, 2507, + 261, 1, 0, 0, 0, 2508, 2510, 5, 343, 0, 0, 2509, 2511, 3, 430, 215, 0, + 2510, 2509, 1, 0, 0, 0, 2510, 2511, 1, 0, 0, 0, 2511, 2513, 1, 0, 0, 0, + 2512, 2514, 3, 432, 216, 0, 2513, 2512, 1, 0, 0, 0, 2513, 2514, 1, 0, 0, + 0, 2514, 2515, 1, 0, 0, 0, 2515, 2516, 5, 171, 0, 0, 2516, 2517, 5, 268, + 0, 0, 2517, 2518, 5, 178, 0, 0, 2518, 2519, 6, 131, -1, 0, 2519, 263, 1, + 0, 0, 0, 2520, 2522, 5, 343, 0, 0, 2521, 2523, 3, 430, 215, 0, 2522, 2521, + 1, 0, 0, 0, 2522, 2523, 1, 0, 0, 0, 2523, 2525, 1, 0, 0, 0, 2524, 2526, + 3, 432, 216, 0, 2525, 2524, 1, 0, 0, 0, 2525, 2526, 1, 0, 0, 0, 2526, 2527, + 1, 0, 0, 0, 2527, 2528, 5, 171, 0, 0, 2528, 2530, 5, 268, 0, 0, 2529, 2531, + 3, 670, 335, 0, 2530, 2529, 1, 0, 0, 0, 2530, 2531, 1, 0, 0, 0, 2531, 2532, + 1, 0, 0, 0, 2532, 2534, 3, 858, 429, 0, 2533, 2535, 3, 550, 275, 0, 2534, + 2533, 1, 0, 0, 0, 2534, 2535, 1, 0, 0, 0, 2535, 2537, 1, 0, 0, 0, 2536, + 2538, 3, 268, 134, 0, 2537, 2536, 1, 0, 0, 0, 2537, 2538, 1, 0, 0, 0, 2538, + 2540, 1, 0, 0, 0, 2539, 2541, 3, 266, 133, 0, 2540, 2539, 1, 0, 0, 0, 2540, + 2541, 1, 0, 0, 0, 2541, 2543, 1, 0, 0, 0, 2542, 2544, 3, 538, 269, 0, 2543, + 2542, 1, 0, 0, 0, 2543, 2544, 1, 0, 0, 0, 2544, 2546, 1, 0, 0, 0, 2545, + 2547, 3, 696, 348, 0, 2546, 2545, 1, 0, 0, 0, 2546, 2547, 1, 0, 0, 0, 2547, + 265, 1, 0, 0, 0, 2548, 2549, 5, 324, 0, 0, 2549, 2550, 3, 1172, 586, 0, + 2550, 267, 1, 0, 0, 0, 2551, 2552, 5, 335, 0, 0, 2552, 2553, 3, 858, 429, + 0, 2553, 269, 1, 0, 0, 0, 2554, 2556, 5, 343, 0, 0, 2555, 2557, 3, 430, + 215, 0, 2556, 2555, 1, 0, 0, 0, 2556, 2557, 1, 0, 0, 0, 2557, 2558, 1, + 0, 0, 0, 2558, 2560, 5, 249, 0, 0, 2559, 2561, 5, 123, 0, 0, 2560, 2559, + 1, 0, 0, 0, 2560, 2561, 1, 0, 0, 0, 2561, 2562, 1, 0, 0, 0, 2562, 2564, + 5, 224, 0, 0, 2563, 2565, 3, 670, 335, 0, 2564, 2563, 1, 0, 0, 0, 2564, + 2565, 1, 0, 0, 0, 2565, 2567, 1, 0, 0, 0, 2566, 2568, 3, 1200, 600, 0, + 2567, 2566, 1, 0, 0, 0, 2567, 2568, 1, 0, 0, 0, 2568, 2569, 1, 0, 0, 0, + 2569, 2570, 5, 84, 0, 0, 2570, 2572, 3, 1198, 599, 0, 2571, 2573, 3, 274, + 137, 0, 2572, 2571, 1, 0, 0, 0, 2572, 2573, 1, 0, 0, 0, 2573, 2574, 1, + 0, 0, 0, 2574, 2575, 3, 272, 136, 0, 2575, 271, 1, 0, 0, 0, 2576, 2578, + 5, 173, 0, 0, 2577, 2576, 1, 0, 0, 0, 2577, 2578, 1, 0, 0, 0, 2578, 2579, + 1, 0, 0, 0, 2579, 2580, 5, 102, 0, 0, 2580, 2581, 5, 21, 0, 0, 2581, 2582, + 3, 952, 476, 0, 2582, 2583, 5, 22, 0, 0, 2583, 273, 1, 0, 0, 0, 2584, 2588, + 3, 568, 284, 0, 2585, 2586, 5, 331, 0, 0, 2586, 2588, 3, 570, 285, 0, 2587, + 2584, 1, 0, 0, 0, 2587, 2585, 1, 0, 0, 0, 2588, 275, 1, 0, 0, 0, 2589, + 2591, 5, 343, 0, 0, 2590, 2592, 3, 430, 215, 0, 2591, 2590, 1, 0, 0, 0, + 2591, 2592, 1, 0, 0, 0, 2592, 2593, 1, 0, 0, 0, 2593, 2594, 5, 227, 0, + 0, 2594, 2596, 5, 244, 0, 0, 2595, 2597, 3, 670, 335, 0, 2596, 2595, 1, + 0, 0, 0, 2596, 2597, 1, 0, 0, 0, 2597, 2598, 1, 0, 0, 0, 2598, 2599, 5, + 84, 0, 0, 2599, 2600, 3, 572, 286, 0, 2600, 2601, 5, 84, 0, 0, 2601, 2602, + 3, 1200, 600, 0, 2602, 2604, 3, 1198, 599, 0, 2603, 2605, 3, 278, 139, + 0, 2604, 2603, 1, 0, 0, 0, 2604, 2605, 1, 0, 0, 0, 2605, 277, 1, 0, 0, + 0, 2606, 2607, 5, 243, 0, 0, 2607, 2608, 5, 331, 0, 0, 2608, 2609, 3, 280, + 140, 0, 2609, 279, 1, 0, 0, 0, 2610, 2619, 5, 21, 0, 0, 2611, 2616, 3, + 1174, 587, 0, 2612, 2613, 5, 17, 0, 0, 2613, 2615, 3, 1174, 587, 0, 2614, + 2612, 1, 0, 0, 0, 2615, 2618, 1, 0, 0, 0, 2616, 2614, 1, 0, 0, 0, 2616, + 2617, 1, 0, 0, 0, 2617, 2620, 1, 0, 0, 0, 2618, 2616, 1, 0, 0, 0, 2619, + 2611, 1, 0, 0, 0, 2619, 2620, 1, 0, 0, 0, 2620, 2621, 1, 0, 0, 0, 2621, + 2622, 5, 22, 0, 0, 2622, 281, 1, 0, 0, 0, 2623, 2625, 5, 343, 0, 0, 2624, + 2626, 3, 430, 215, 0, 2625, 2624, 1, 0, 0, 0, 2625, 2626, 1, 0, 0, 0, 2626, + 2628, 1, 0, 0, 0, 2627, 2629, 5, 278, 0, 0, 2628, 2627, 1, 0, 0, 0, 2628, + 2629, 1, 0, 0, 0, 2629, 2631, 1, 0, 0, 0, 2630, 2632, 3, 310, 155, 0, 2631, + 2630, 1, 0, 0, 0, 2631, 2632, 1, 0, 0, 0, 2632, 2634, 1, 0, 0, 0, 2633, + 2635, 3, 308, 154, 0, 2634, 2633, 1, 0, 0, 0, 2634, 2635, 1, 0, 0, 0, 2635, + 2636, 1, 0, 0, 0, 2636, 2638, 5, 188, 0, 0, 2637, 2639, 3, 670, 335, 0, + 2638, 2637, 1, 0, 0, 0, 2638, 2639, 1, 0, 0, 0, 2639, 2640, 1, 0, 0, 0, + 2640, 2641, 3, 1198, 599, 0, 2641, 2643, 3, 306, 153, 0, 2642, 2644, 3, + 800, 400, 0, 2643, 2642, 1, 0, 0, 0, 2643, 2644, 1, 0, 0, 0, 2644, 2646, + 1, 0, 0, 0, 2645, 2647, 3, 302, 151, 0, 2646, 2645, 1, 0, 0, 0, 2646, 2647, + 1, 0, 0, 0, 2647, 2648, 1, 0, 0, 0, 2648, 2650, 3, 292, 146, 0, 2649, 2651, + 3, 288, 144, 0, 2650, 2649, 1, 0, 0, 0, 2650, 2651, 1, 0, 0, 0, 2651, 2653, + 1, 0, 0, 0, 2652, 2654, 3, 284, 142, 0, 2653, 2652, 1, 0, 0, 0, 2653, 2654, + 1, 0, 0, 0, 2654, 283, 1, 0, 0, 0, 2655, 2657, 3, 818, 409, 0, 2656, 2658, + 3, 696, 348, 0, 2657, 2656, 1, 0, 0, 0, 2657, 2658, 1, 0, 0, 0, 2658, 2665, + 1, 0, 0, 0, 2659, 2661, 3, 696, 348, 0, 2660, 2659, 1, 0, 0, 0, 2660, 2661, + 1, 0, 0, 0, 2661, 2662, 1, 0, 0, 0, 2662, 2665, 3, 286, 143, 0, 2663, 2665, + 3, 696, 348, 0, 2664, 2655, 1, 0, 0, 0, 2664, 2660, 1, 0, 0, 0, 2664, 2663, + 1, 0, 0, 0, 2665, 285, 1, 0, 0, 0, 2666, 2667, 5, 17, 0, 0, 2667, 2668, + 5, 292, 0, 0, 2668, 2669, 5, 73, 0, 0, 2669, 2670, 3, 858, 429, 0, 2670, + 287, 1, 0, 0, 0, 2671, 2672, 5, 266, 0, 0, 2672, 2673, 3, 290, 145, 0, + 2673, 289, 1, 0, 0, 0, 2674, 2675, 5, 21, 0, 0, 2675, 2680, 3, 952, 476, + 0, 2676, 2677, 5, 17, 0, 0, 2677, 2679, 3, 952, 476, 0, 2678, 2676, 1, + 0, 0, 0, 2679, 2682, 1, 0, 0, 0, 2680, 2678, 1, 0, 0, 0, 2680, 2681, 1, + 0, 0, 0, 2681, 2683, 1, 0, 0, 0, 2682, 2680, 1, 0, 0, 0, 2683, 2684, 5, + 22, 0, 0, 2684, 291, 1, 0, 0, 0, 2685, 2686, 5, 21, 0, 0, 2686, 2691, 3, + 300, 150, 0, 2687, 2688, 5, 17, 0, 0, 2688, 2690, 3, 300, 150, 0, 2689, + 2687, 1, 0, 0, 0, 2690, 2693, 1, 0, 0, 0, 2691, 2689, 1, 0, 0, 0, 2691, + 2692, 1, 0, 0, 0, 2692, 2694, 1, 0, 0, 0, 2693, 2691, 1, 0, 0, 0, 2694, + 2695, 5, 22, 0, 0, 2695, 2698, 1, 0, 0, 0, 2696, 2698, 3, 294, 147, 0, + 2697, 2685, 1, 0, 0, 0, 2697, 2696, 1, 0, 0, 0, 2698, 293, 1, 0, 0, 0, + 2699, 2700, 5, 21, 0, 0, 2700, 2701, 5, 57, 0, 0, 2701, 2703, 5, 144, 0, + 0, 2702, 2704, 3, 296, 148, 0, 2703, 2702, 1, 0, 0, 0, 2703, 2704, 1, 0, + 0, 0, 2704, 2705, 1, 0, 0, 0, 2705, 2706, 5, 22, 0, 0, 2706, 295, 1, 0, + 0, 0, 2707, 2708, 5, 104, 0, 0, 2708, 2709, 5, 143, 0, 0, 2709, 2710, 5, + 85, 0, 0, 2710, 2711, 3, 298, 149, 0, 2711, 297, 1, 0, 0, 0, 2712, 2713, + 5, 21, 0, 0, 2713, 2718, 3, 300, 150, 0, 2714, 2715, 5, 17, 0, 0, 2715, + 2717, 3, 300, 150, 0, 2716, 2714, 1, 0, 0, 0, 2717, 2720, 1, 0, 0, 0, 2718, + 2716, 1, 0, 0, 0, 2718, 2719, 1, 0, 0, 0, 2719, 2721, 1, 0, 0, 0, 2720, + 2718, 1, 0, 0, 0, 2721, 2722, 5, 22, 0, 0, 2722, 299, 1, 0, 0, 0, 2723, + 2725, 3, 952, 476, 0, 2724, 2726, 3, 1172, 586, 0, 2725, 2724, 1, 0, 0, + 0, 2725, 2726, 1, 0, 0, 0, 2726, 2728, 1, 0, 0, 0, 2727, 2729, 3, 1094, + 547, 0, 2728, 2727, 1, 0, 0, 0, 2728, 2729, 1, 0, 0, 0, 2729, 2731, 1, + 0, 0, 0, 2730, 2732, 3, 1096, 548, 0, 2731, 2730, 1, 0, 0, 0, 2731, 2732, + 1, 0, 0, 0, 2732, 2734, 1, 0, 0, 0, 2733, 2735, 3, 696, 348, 0, 2734, 2733, + 1, 0, 0, 0, 2734, 2735, 1, 0, 0, 0, 2735, 301, 1, 0, 0, 0, 2736, 2738, + 3, 304, 152, 0, 2737, 2736, 1, 0, 0, 0, 2738, 2739, 1, 0, 0, 0, 2739, 2737, + 1, 0, 0, 0, 2739, 2740, 1, 0, 0, 0, 2740, 303, 1, 0, 0, 0, 2741, 2743, + 3, 872, 436, 0, 2742, 2744, 3, 800, 400, 0, 2743, 2742, 1, 0, 0, 0, 2743, + 2744, 1, 0, 0, 0, 2744, 2746, 1, 0, 0, 0, 2745, 2747, 3, 850, 425, 0, 2746, + 2745, 1, 0, 0, 0, 2746, 2747, 1, 0, 0, 0, 2747, 305, 1, 0, 0, 0, 2748, + 2749, 5, 84, 0, 0, 2749, 2750, 3, 1198, 599, 0, 2750, 307, 1, 0, 0, 0, + 2751, 2752, 7, 7, 0, 0, 2752, 309, 1, 0, 0, 0, 2753, 2754, 5, 293, 0, 0, + 2754, 311, 1, 0, 0, 0, 2755, 2757, 5, 343, 0, 0, 2756, 2758, 3, 430, 215, + 0, 2757, 2756, 1, 0, 0, 0, 2757, 2758, 1, 0, 0, 0, 2758, 2760, 1, 0, 0, + 0, 2759, 2761, 3, 432, 216, 0, 2760, 2759, 1, 0, 0, 0, 2760, 2761, 1, 0, + 0, 0, 2761, 2762, 1, 0, 0, 0, 2762, 2764, 5, 229, 0, 0, 2763, 2765, 3, + 670, 335, 0, 2764, 2763, 1, 0, 0, 0, 2764, 2765, 1, 0, 0, 0, 2765, 2766, + 1, 0, 0, 0, 2766, 2767, 3, 1198, 599, 0, 2767, 2769, 3, 368, 184, 0, 2768, + 2770, 3, 364, 182, 0, 2769, 2768, 1, 0, 0, 0, 2769, 2770, 1, 0, 0, 0, 2770, + 2772, 1, 0, 0, 0, 2771, 2773, 3, 396, 198, 0, 2772, 2771, 1, 0, 0, 0, 2772, + 2773, 1, 0, 0, 0, 2773, 2775, 1, 0, 0, 0, 2774, 2776, 3, 696, 348, 0, 2775, + 2774, 1, 0, 0, 0, 2775, 2776, 1, 0, 0, 0, 2776, 2777, 1, 0, 0, 0, 2777, + 2778, 3, 314, 157, 0, 2778, 313, 1, 0, 0, 0, 2779, 2786, 3, 316, 158, 0, + 2780, 2781, 5, 196, 0, 0, 2781, 2783, 3, 1200, 600, 0, 2782, 2784, 3, 362, + 181, 0, 2783, 2782, 1, 0, 0, 0, 2783, 2784, 1, 0, 0, 0, 2784, 2786, 1, + 0, 0, 0, 2785, 2779, 1, 0, 0, 0, 2785, 2780, 1, 0, 0, 0, 2786, 315, 1, + 0, 0, 0, 2787, 2789, 5, 134, 0, 0, 2788, 2790, 3, 320, 160, 0, 2789, 2788, + 1, 0, 0, 0, 2789, 2790, 1, 0, 0, 0, 2790, 2792, 1, 0, 0, 0, 2791, 2793, + 3, 318, 159, 0, 2792, 2791, 1, 0, 0, 0, 2792, 2793, 1, 0, 0, 0, 2793, 2794, + 1, 0, 0, 0, 2794, 2795, 5, 296, 0, 0, 2795, 317, 1, 0, 0, 0, 2796, 2797, + 5, 166, 0, 0, 2797, 2798, 5, 298, 0, 0, 2798, 2799, 5, 165, 0, 0, 2799, + 2800, 5, 299, 0, 0, 2800, 2801, 3, 320, 160, 0, 2801, 319, 1, 0, 0, 0, + 2802, 2803, 3, 322, 161, 0, 2803, 2804, 5, 27, 0, 0, 2804, 321, 1, 0, 0, + 0, 2805, 2810, 3, 324, 162, 0, 2806, 2807, 5, 27, 0, 0, 2807, 2809, 3, + 324, 162, 0, 2808, 2806, 1, 0, 0, 0, 2809, 2812, 1, 0, 0, 0, 2810, 2808, + 1, 0, 0, 0, 2810, 2811, 1, 0, 0, 0, 2811, 323, 1, 0, 0, 0, 2812, 2810, + 1, 0, 0, 0, 2813, 2816, 3, 4, 2, 0, 2814, 2816, 3, 326, 163, 0, 2815, 2813, + 1, 0, 0, 0, 2815, 2814, 1, 0, 0, 0, 2816, 325, 1, 0, 0, 0, 2817, 2832, + 3, 356, 178, 0, 2818, 2832, 3, 352, 176, 0, 2819, 2832, 3, 348, 174, 0, + 2820, 2832, 3, 350, 175, 0, 2821, 2832, 3, 346, 173, 0, 2822, 2832, 3, + 344, 172, 0, 2823, 2832, 3, 342, 171, 0, 2824, 2832, 3, 330, 165, 0, 2825, + 2826, 3, 328, 164, 0, 2826, 2827, 5, 26, 0, 0, 2827, 2829, 3, 330, 165, + 0, 2828, 2830, 3, 1200, 600, 0, 2829, 2828, 1, 0, 0, 0, 2829, 2830, 1, + 0, 0, 0, 2830, 2832, 1, 0, 0, 0, 2831, 2817, 1, 0, 0, 0, 2831, 2818, 1, + 0, 0, 0, 2831, 2819, 1, 0, 0, 0, 2831, 2820, 1, 0, 0, 0, 2831, 2821, 1, + 0, 0, 0, 2831, 2822, 1, 0, 0, 0, 2831, 2823, 1, 0, 0, 0, 2831, 2824, 1, + 0, 0, 0, 2831, 2825, 1, 0, 0, 0, 2832, 327, 1, 0, 0, 0, 2833, 2834, 3, + 1200, 600, 0, 2834, 329, 1, 0, 0, 0, 2835, 2841, 3, 316, 158, 0, 2836, + 2841, 3, 340, 170, 0, 2837, 2841, 3, 338, 169, 0, 2838, 2841, 3, 334, 167, + 0, 2839, 2841, 3, 332, 166, 0, 2840, 2835, 1, 0, 0, 0, 2840, 2836, 1, 0, + 0, 0, 2840, 2837, 1, 0, 0, 0, 2840, 2838, 1, 0, 0, 0, 2840, 2839, 1, 0, + 0, 0, 2841, 331, 1, 0, 0, 0, 2842, 2843, 5, 70, 0, 0, 2843, 2844, 3, 1200, + 600, 0, 2844, 2845, 5, 73, 0, 0, 2845, 2846, 3, 978, 489, 0, 2846, 2848, + 5, 161, 0, 0, 2847, 2849, 3, 320, 160, 0, 2848, 2847, 1, 0, 0, 0, 2848, + 2849, 1, 0, 0, 0, 2849, 2850, 1, 0, 0, 0, 2850, 2851, 5, 296, 0, 0, 2851, + 2852, 5, 70, 0, 0, 2852, 333, 1, 0, 0, 0, 2853, 2855, 5, 238, 0, 0, 2854, + 2856, 3, 320, 160, 0, 2855, 2854, 1, 0, 0, 0, 2855, 2856, 1, 0, 0, 0, 2856, + 2857, 1, 0, 0, 0, 2857, 2858, 3, 336, 168, 0, 2858, 2859, 5, 296, 0, 0, + 2859, 2860, 5, 238, 0, 0, 2860, 335, 1, 0, 0, 0, 2861, 2862, 5, 280, 0, + 0, 2862, 2863, 3, 952, 476, 0, 2863, 337, 1, 0, 0, 0, 2864, 2866, 5, 201, + 0, 0, 2865, 2867, 3, 320, 160, 0, 2866, 2865, 1, 0, 0, 0, 2866, 2867, 1, + 0, 0, 0, 2867, 2868, 1, 0, 0, 0, 2868, 2869, 5, 296, 0, 0, 2869, 2870, + 5, 201, 0, 0, 2870, 339, 1, 0, 0, 0, 2871, 2872, 5, 288, 0, 0, 2872, 2873, + 3, 952, 476, 0, 2873, 2875, 5, 161, 0, 0, 2874, 2876, 3, 320, 160, 0, 2875, + 2874, 1, 0, 0, 0, 2875, 2876, 1, 0, 0, 0, 2876, 2877, 1, 0, 0, 0, 2877, + 2878, 5, 296, 0, 0, 2878, 2879, 5, 288, 0, 0, 2879, 341, 1, 0, 0, 0, 2880, + 2887, 5, 232, 0, 0, 2881, 2882, 5, 232, 0, 0, 2882, 2883, 5, 102, 0, 0, + 2883, 2884, 5, 211, 0, 0, 2884, 2885, 5, 1, 0, 0, 2885, 2887, 3, 952, 476, + 0, 2886, 2880, 1, 0, 0, 0, 2886, 2881, 1, 0, 0, 0, 2887, 343, 1, 0, 0, + 0, 2888, 2889, 5, 246, 0, 0, 2889, 345, 1, 0, 0, 0, 2890, 2892, 5, 149, + 0, 0, 2891, 2893, 3, 1200, 600, 0, 2892, 2891, 1, 0, 0, 0, 2892, 2893, + 1, 0, 0, 0, 2893, 2899, 1, 0, 0, 0, 2894, 2896, 5, 194, 0, 0, 2895, 2897, + 3, 1200, 600, 0, 2896, 2895, 1, 0, 0, 0, 2896, 2897, 1, 0, 0, 0, 2897, + 2899, 1, 0, 0, 0, 2898, 2890, 1, 0, 0, 0, 2898, 2894, 1, 0, 0, 0, 2899, + 347, 1, 0, 0, 0, 2900, 2901, 5, 154, 0, 0, 2901, 2902, 3, 446, 223, 0, + 2902, 2904, 3, 1170, 585, 0, 2903, 2905, 3, 410, 205, 0, 2904, 2903, 1, + 0, 0, 0, 2904, 2905, 1, 0, 0, 0, 2905, 2912, 1, 0, 0, 0, 2906, 2907, 5, + 154, 0, 0, 2907, 2908, 3, 446, 223, 0, 2908, 2909, 5, 324, 0, 0, 2909, + 2910, 3, 952, 476, 0, 2910, 2912, 1, 0, 0, 0, 2911, 2900, 1, 0, 0, 0, 2911, + 2906, 1, 0, 0, 0, 2912, 349, 1, 0, 0, 0, 2913, 2915, 5, 135, 0, 0, 2914, + 2916, 3, 1200, 600, 0, 2915, 2914, 1, 0, 0, 0, 2915, 2916, 1, 0, 0, 0, + 2916, 2922, 1, 0, 0, 0, 2917, 2919, 5, 198, 0, 0, 2918, 2920, 3, 1200, + 600, 0, 2919, 2918, 1, 0, 0, 0, 2919, 2920, 1, 0, 0, 0, 2920, 2922, 1, + 0, 0, 0, 2921, 2913, 1, 0, 0, 0, 2921, 2917, 1, 0, 0, 0, 2922, 351, 1, + 0, 0, 0, 2923, 2925, 5, 297, 0, 0, 2924, 2926, 3, 952, 476, 0, 2925, 2924, + 1, 0, 0, 0, 2925, 2926, 1, 0, 0, 0, 2926, 2927, 1, 0, 0, 0, 2927, 2929, + 3, 354, 177, 0, 2928, 2930, 3, 360, 180, 0, 2929, 2928, 1, 0, 0, 0, 2929, + 2930, 1, 0, 0, 0, 2930, 2931, 1, 0, 0, 0, 2931, 2932, 5, 296, 0, 0, 2932, + 2933, 5, 297, 0, 0, 2933, 353, 1, 0, 0, 0, 2934, 2935, 5, 298, 0, 0, 2935, + 2936, 3, 952, 476, 0, 2936, 2938, 5, 299, 0, 0, 2937, 2939, 3, 320, 160, + 0, 2938, 2937, 1, 0, 0, 0, 2938, 2939, 1, 0, 0, 0, 2939, 2941, 1, 0, 0, + 0, 2940, 2934, 1, 0, 0, 0, 2941, 2942, 1, 0, 0, 0, 2942, 2940, 1, 0, 0, + 0, 2942, 2943, 1, 0, 0, 0, 2943, 355, 1, 0, 0, 0, 2944, 2945, 5, 304, 0, + 0, 2945, 2946, 3, 952, 476, 0, 2946, 2948, 5, 299, 0, 0, 2947, 2949, 3, + 320, 160, 0, 2948, 2947, 1, 0, 0, 0, 2948, 2949, 1, 0, 0, 0, 2949, 2951, + 1, 0, 0, 0, 2950, 2952, 3, 358, 179, 0, 2951, 2950, 1, 0, 0, 0, 2951, 2952, + 1, 0, 0, 0, 2952, 2954, 1, 0, 0, 0, 2953, 2955, 3, 360, 180, 0, 2954, 2953, + 1, 0, 0, 0, 2954, 2955, 1, 0, 0, 0, 2955, 2956, 1, 0, 0, 0, 2956, 2957, + 5, 296, 0, 0, 2957, 2958, 5, 304, 0, 0, 2958, 357, 1, 0, 0, 0, 2959, 2960, + 5, 163, 0, 0, 2960, 2961, 3, 952, 476, 0, 2961, 2963, 5, 299, 0, 0, 2962, + 2964, 3, 320, 160, 0, 2963, 2962, 1, 0, 0, 0, 2963, 2964, 1, 0, 0, 0, 2964, + 2966, 1, 0, 0, 0, 2965, 2959, 1, 0, 0, 0, 2966, 2967, 1, 0, 0, 0, 2967, + 2965, 1, 0, 0, 0, 2967, 2968, 1, 0, 0, 0, 2968, 359, 1, 0, 0, 0, 2969, + 2971, 5, 300, 0, 0, 2970, 2972, 3, 320, 160, 0, 2971, 2970, 1, 0, 0, 0, + 2971, 2972, 1, 0, 0, 0, 2972, 361, 1, 0, 0, 0, 2973, 2974, 5, 58, 0, 0, + 2974, 2975, 3, 1244, 622, 0, 2975, 363, 1, 0, 0, 0, 2976, 2977, 5, 171, + 0, 0, 2977, 2978, 5, 254, 0, 0, 2978, 2979, 3, 366, 183, 0, 2979, 365, + 1, 0, 0, 0, 2980, 2981, 7, 8, 0, 0, 2981, 367, 1, 0, 0, 0, 2982, 2991, + 5, 21, 0, 0, 2983, 2988, 3, 370, 185, 0, 2984, 2985, 5, 17, 0, 0, 2985, + 2987, 3, 370, 185, 0, 2986, 2984, 1, 0, 0, 0, 2987, 2990, 1, 0, 0, 0, 2988, + 2986, 1, 0, 0, 0, 2988, 2989, 1, 0, 0, 0, 2989, 2992, 1, 0, 0, 0, 2990, + 2988, 1, 0, 0, 0, 2991, 2983, 1, 0, 0, 0, 2991, 2992, 1, 0, 0, 0, 2992, + 2993, 1, 0, 0, 0, 2993, 2994, 5, 22, 0, 0, 2994, 369, 1, 0, 0, 0, 2995, + 2997, 3, 374, 187, 0, 2996, 2995, 1, 0, 0, 0, 2996, 2997, 1, 0, 0, 0, 2997, + 2998, 1, 0, 0, 0, 2998, 2999, 3, 1200, 600, 0, 2999, 3000, 3, 412, 206, + 0, 3000, 3009, 1, 0, 0, 0, 3001, 3003, 3, 374, 187, 0, 3002, 3001, 1, 0, + 0, 0, 3002, 3003, 1, 0, 0, 0, 3003, 3004, 1, 0, 0, 0, 3004, 3005, 3, 1200, + 600, 0, 3005, 3006, 3, 372, 186, 0, 3006, 3007, 6, 185, -1, 0, 3007, 3009, + 1, 0, 0, 0, 3008, 2996, 1, 0, 0, 0, 3008, 3002, 1, 0, 0, 0, 3009, 371, + 1, 0, 0, 0, 3010, 3011, 7, 9, 0, 0, 3011, 373, 1, 0, 0, 0, 3012, 3013, + 7, 10, 0, 0, 3013, 375, 1, 0, 0, 0, 3014, 3016, 5, 343, 0, 0, 3015, 3017, + 3, 430, 215, 0, 3016, 3015, 1, 0, 0, 0, 3016, 3017, 1, 0, 0, 0, 3017, 3019, + 1, 0, 0, 0, 3018, 3020, 3, 432, 216, 0, 3019, 3018, 1, 0, 0, 0, 3019, 3020, + 1, 0, 0, 0, 3020, 3022, 1, 0, 0, 0, 3021, 3023, 3, 422, 211, 0, 3022, 3021, + 1, 0, 0, 0, 3022, 3023, 1, 0, 0, 0, 3023, 3024, 1, 0, 0, 0, 3024, 3026, + 5, 178, 0, 0, 3025, 3027, 3, 670, 335, 0, 3026, 3025, 1, 0, 0, 0, 3026, + 3027, 1, 0, 0, 0, 3027, 3028, 1, 0, 0, 0, 3028, 3030, 3, 402, 201, 0, 3029, + 3031, 3, 398, 199, 0, 3030, 3029, 1, 0, 0, 0, 3030, 3031, 1, 0, 0, 0, 3031, + 3033, 1, 0, 0, 0, 3032, 3034, 3, 380, 190, 0, 3033, 3032, 1, 0, 0, 0, 3033, + 3034, 1, 0, 0, 0, 3034, 3036, 1, 0, 0, 0, 3035, 3037, 3, 378, 189, 0, 3036, + 3035, 1, 0, 0, 0, 3036, 3037, 1, 0, 0, 0, 3037, 3039, 1, 0, 0, 0, 3038, + 3040, 3, 390, 195, 0, 3039, 3038, 1, 0, 0, 0, 3039, 3040, 1, 0, 0, 0, 3040, + 3042, 1, 0, 0, 0, 3041, 3043, 3, 388, 194, 0, 3042, 3041, 1, 0, 0, 0, 3042, + 3043, 1, 0, 0, 0, 3043, 377, 1, 0, 0, 0, 3044, 3051, 5, 160, 0, 0, 3045, + 3046, 5, 111, 0, 0, 3046, 3051, 5, 160, 0, 0, 3047, 3051, 5, 185, 0, 0, + 3048, 3051, 5, 262, 0, 0, 3049, 3051, 5, 286, 0, 0, 3050, 3044, 1, 0, 0, + 0, 3050, 3045, 1, 0, 0, 0, 3050, 3047, 1, 0, 0, 0, 3050, 3048, 1, 0, 0, + 0, 3050, 3049, 1, 0, 0, 0, 3051, 379, 1, 0, 0, 0, 3052, 3053, 5, 261, 0, + 0, 3053, 3054, 5, 254, 0, 0, 3054, 3055, 3, 382, 191, 0, 3055, 381, 1, + 0, 0, 0, 3056, 3057, 7, 8, 0, 0, 3057, 383, 1, 0, 0, 0, 3058, 3059, 5, + 58, 0, 0, 3059, 3063, 3, 386, 193, 0, 3060, 3061, 5, 58, 0, 0, 3061, 3063, + 3, 1244, 622, 0, 3062, 3058, 1, 0, 0, 0, 3062, 3060, 1, 0, 0, 0, 3063, + 385, 1, 0, 0, 0, 3064, 3065, 5, 21, 0, 0, 3065, 3066, 3, 952, 476, 0, 3066, + 3067, 5, 22, 0, 0, 3067, 3072, 1, 0, 0, 0, 3068, 3069, 5, 21, 0, 0, 3069, + 3070, 5, 95, 0, 0, 3070, 3072, 6, 193, -1, 0, 3071, 3064, 1, 0, 0, 0, 3071, + 3068, 1, 0, 0, 0, 3072, 387, 1, 0, 0, 0, 3073, 3075, 3, 696, 348, 0, 3074, + 3076, 3, 384, 192, 0, 3075, 3074, 1, 0, 0, 0, 3075, 3076, 1, 0, 0, 0, 3076, + 3082, 1, 0, 0, 0, 3077, 3079, 3, 384, 192, 0, 3078, 3080, 3, 696, 348, + 0, 3079, 3078, 1, 0, 0, 0, 3079, 3080, 1, 0, 0, 0, 3080, 3082, 1, 0, 0, + 0, 3081, 3073, 1, 0, 0, 0, 3081, 3077, 1, 0, 0, 0, 3082, 389, 1, 0, 0, + 0, 3083, 3084, 5, 196, 0, 0, 3084, 3086, 3, 1200, 600, 0, 3085, 3087, 3, + 394, 197, 0, 3086, 3085, 1, 0, 0, 0, 3086, 3087, 1, 0, 0, 0, 3087, 3093, + 1, 0, 0, 0, 3088, 3090, 3, 394, 197, 0, 3089, 3091, 3, 392, 196, 0, 3090, + 3089, 1, 0, 0, 0, 3090, 3091, 1, 0, 0, 0, 3091, 3093, 1, 0, 0, 0, 3092, + 3083, 1, 0, 0, 0, 3092, 3088, 1, 0, 0, 0, 3093, 391, 1, 0, 0, 0, 3094, + 3095, 5, 196, 0, 0, 3095, 3096, 3, 1200, 600, 0, 3096, 393, 1, 0, 0, 0, + 3097, 3099, 5, 235, 0, 0, 3098, 3100, 3, 396, 198, 0, 3099, 3098, 1, 0, + 0, 0, 3099, 3100, 1, 0, 0, 0, 3100, 3103, 1, 0, 0, 0, 3101, 3103, 3, 396, + 198, 0, 3102, 3097, 1, 0, 0, 0, 3102, 3101, 1, 0, 0, 0, 3103, 395, 1, 0, + 0, 0, 3104, 3105, 5, 104, 0, 0, 3105, 3106, 3, 884, 442, 0, 3106, 397, + 1, 0, 0, 0, 3107, 3108, 3, 400, 200, 0, 3108, 399, 1, 0, 0, 0, 3109, 3110, + 5, 245, 0, 0, 3110, 3111, 3, 412, 206, 0, 3111, 401, 1, 0, 0, 0, 3112, + 3113, 3, 1198, 599, 0, 3113, 3114, 3, 404, 202, 0, 3114, 403, 1, 0, 0, + 0, 3115, 3124, 5, 21, 0, 0, 3116, 3121, 3, 406, 203, 0, 3117, 3118, 5, + 17, 0, 0, 3118, 3120, 3, 406, 203, 0, 3119, 3117, 1, 0, 0, 0, 3120, 3123, + 1, 0, 0, 0, 3121, 3119, 1, 0, 0, 0, 3121, 3122, 1, 0, 0, 0, 3122, 3125, + 1, 0, 0, 0, 3123, 3121, 1, 0, 0, 0, 3124, 3116, 1, 0, 0, 0, 3124, 3125, + 1, 0, 0, 0, 3125, 3126, 1, 0, 0, 0, 3126, 3127, 5, 22, 0, 0, 3127, 405, + 1, 0, 0, 0, 3128, 3129, 3, 1200, 600, 0, 3129, 3131, 3, 412, 206, 0, 3130, + 3132, 3, 1088, 544, 0, 3131, 3130, 1, 0, 0, 0, 3131, 3132, 1, 0, 0, 0, + 3132, 3134, 1, 0, 0, 0, 3133, 3135, 3, 410, 205, 0, 3134, 3133, 1, 0, 0, + 0, 3134, 3135, 1, 0, 0, 0, 3135, 3137, 1, 0, 0, 0, 3136, 3138, 3, 408, + 204, 0, 3137, 3136, 1, 0, 0, 0, 3137, 3138, 1, 0, 0, 0, 3138, 3147, 1, + 0, 0, 0, 3139, 3141, 3, 412, 206, 0, 3140, 3142, 3, 1088, 544, 0, 3141, + 3140, 1, 0, 0, 0, 3141, 3142, 1, 0, 0, 0, 3142, 3144, 1, 0, 0, 0, 3143, + 3145, 3, 408, 204, 0, 3144, 3143, 1, 0, 0, 0, 3144, 3145, 1, 0, 0, 0, 3145, + 3147, 1, 0, 0, 0, 3146, 3128, 1, 0, 0, 0, 3146, 3139, 1, 0, 0, 0, 3147, + 407, 1, 0, 0, 0, 3148, 3149, 5, 111, 0, 0, 3149, 3150, 5, 125, 0, 0, 3150, + 409, 1, 0, 0, 0, 3151, 3152, 5, 324, 0, 0, 3152, 3153, 3, 952, 476, 0, + 3153, 411, 1, 0, 0, 0, 3154, 3158, 3, 1170, 585, 0, 3155, 3158, 3, 418, + 209, 0, 3156, 3158, 3, 414, 207, 0, 3157, 3154, 1, 0, 0, 0, 3157, 3155, + 1, 0, 0, 0, 3157, 3156, 1, 0, 0, 0, 3158, 413, 1, 0, 0, 0, 3159, 3160, + 5, 268, 0, 0, 3160, 3161, 3, 1216, 608, 0, 3161, 3166, 3, 416, 208, 0, + 3162, 3163, 5, 17, 0, 0, 3163, 3165, 3, 416, 208, 0, 3164, 3162, 1, 0, + 0, 0, 3165, 3168, 1, 0, 0, 0, 3166, 3164, 1, 0, 0, 0, 3166, 3167, 1, 0, + 0, 0, 3167, 3169, 1, 0, 0, 0, 3168, 3166, 1, 0, 0, 0, 3169, 3170, 3, 1218, + 609, 0, 3170, 415, 1, 0, 0, 0, 3171, 3172, 3, 1200, 600, 0, 3172, 3173, + 3, 1170, 585, 0, 3173, 3176, 1, 0, 0, 0, 3174, 3176, 3, 1170, 585, 0, 3175, + 3171, 1, 0, 0, 0, 3175, 3174, 1, 0, 0, 0, 3176, 417, 1, 0, 0, 0, 3177, + 3178, 5, 333, 0, 0, 3178, 3179, 3, 420, 210, 0, 3179, 419, 1, 0, 0, 0, + 3180, 3186, 5, 311, 0, 0, 3181, 3186, 5, 344, 0, 0, 3182, 3186, 5, 96, + 0, 0, 3183, 3186, 5, 56, 0, 0, 3184, 3186, 3, 1200, 600, 0, 3185, 3180, + 1, 0, 0, 0, 3185, 3181, 1, 0, 0, 0, 3185, 3182, 1, 0, 0, 0, 3185, 3183, + 1, 0, 0, 0, 3185, 3184, 1, 0, 0, 0, 3186, 421, 1, 0, 0, 0, 3187, 3188, + 5, 125, 0, 0, 3188, 423, 1, 0, 0, 0, 3189, 3190, 5, 343, 0, 0, 3190, 3191, + 5, 153, 0, 0, 3191, 3193, 3, 1198, 599, 0, 3192, 3194, 3, 696, 348, 0, + 3193, 3192, 1, 0, 0, 0, 3193, 3194, 1, 0, 0, 0, 3194, 425, 1, 0, 0, 0, + 3195, 3197, 5, 343, 0, 0, 3196, 3198, 3, 430, 215, 0, 3197, 3196, 1, 0, + 0, 0, 3197, 3198, 1, 0, 0, 0, 3198, 3199, 1, 0, 0, 0, 3199, 3201, 5, 146, + 0, 0, 3200, 3202, 3, 670, 335, 0, 3201, 3200, 1, 0, 0, 0, 3201, 3202, 1, + 0, 0, 0, 3202, 3203, 1, 0, 0, 0, 3203, 3205, 3, 1198, 599, 0, 3204, 3206, + 3, 696, 348, 0, 3205, 3204, 1, 0, 0, 0, 3205, 3206, 1, 0, 0, 0, 3206, 427, + 1, 0, 0, 0, 3207, 3209, 5, 343, 0, 0, 3208, 3210, 3, 430, 215, 0, 3209, + 3208, 1, 0, 0, 0, 3209, 3210, 1, 0, 0, 0, 3210, 3212, 1, 0, 0, 0, 3211, + 3213, 3, 432, 216, 0, 3212, 3211, 1, 0, 0, 0, 3212, 3213, 1, 0, 0, 0, 3213, + 3214, 1, 0, 0, 0, 3214, 3216, 5, 147, 0, 0, 3215, 3217, 3, 670, 335, 0, + 3216, 3215, 1, 0, 0, 0, 3216, 3217, 1, 0, 0, 0, 3217, 3218, 1, 0, 0, 0, + 3218, 3219, 3, 1198, 599, 0, 3219, 3220, 5, 1, 0, 0, 3220, 3221, 3, 952, + 476, 0, 3221, 429, 1, 0, 0, 0, 3222, 3223, 5, 113, 0, 0, 3223, 3224, 5, + 93, 0, 0, 3224, 431, 1, 0, 0, 0, 3225, 3226, 7, 11, 0, 0, 3226, 433, 1, + 0, 0, 0, 3227, 3228, 5, 250, 0, 0, 3228, 3229, 5, 133, 0, 0, 3229, 435, + 1, 0, 0, 0, 3230, 3231, 5, 122, 0, 0, 3231, 3232, 5, 133, 0, 0, 3232, 437, + 1, 0, 0, 0, 3233, 3234, 5, 263, 0, 0, 3234, 3236, 5, 133, 0, 0, 3235, 3237, + 3, 1200, 600, 0, 3236, 3235, 1, 0, 0, 0, 3236, 3237, 1, 0, 0, 0, 3237, + 439, 1, 0, 0, 0, 3238, 3240, 5, 248, 0, 0, 3239, 3241, 5, 273, 0, 0, 3240, + 3239, 1, 0, 0, 0, 3240, 3241, 1, 0, 0, 0, 3241, 441, 1, 0, 0, 0, 3242, + 3244, 5, 145, 0, 0, 3243, 3245, 5, 273, 0, 0, 3244, 3243, 1, 0, 0, 0, 3244, + 3245, 1, 0, 0, 0, 3245, 443, 1, 0, 0, 0, 3246, 3247, 5, 257, 0, 0, 3247, + 3248, 5, 273, 0, 0, 3248, 3279, 3, 452, 226, 0, 3249, 3250, 5, 257, 0, + 0, 3250, 3251, 3, 1200, 600, 0, 3251, 3252, 5, 1, 0, 0, 3252, 3253, 3, + 952, 476, 0, 3253, 3279, 1, 0, 0, 0, 3254, 3255, 5, 257, 0, 0, 3255, 3256, + 3, 1180, 590, 0, 3256, 3257, 5, 1, 0, 0, 3257, 3258, 3, 952, 476, 0, 3258, + 3279, 1, 0, 0, 0, 3259, 3260, 5, 257, 0, 0, 3260, 3261, 3, 1176, 588, 0, + 3261, 3262, 5, 1, 0, 0, 3262, 3263, 3, 952, 476, 0, 3263, 3279, 1, 0, 0, + 0, 3264, 3265, 5, 257, 0, 0, 3265, 3266, 5, 21, 0, 0, 3266, 3267, 3, 446, + 223, 0, 3267, 3268, 5, 22, 0, 0, 3268, 3269, 5, 1, 0, 0, 3269, 3270, 3, + 952, 476, 0, 3270, 3279, 1, 0, 0, 0, 3271, 3272, 5, 257, 0, 0, 3272, 3273, + 3, 1200, 600, 0, 3273, 3274, 5, 17, 0, 0, 3274, 3275, 3, 1200, 600, 0, + 3275, 3276, 5, 1, 0, 0, 3276, 3277, 6, 222, -1, 0, 3277, 3279, 1, 0, 0, + 0, 3278, 3246, 1, 0, 0, 0, 3278, 3249, 1, 0, 0, 0, 3278, 3254, 1, 0, 0, + 0, 3278, 3259, 1, 0, 0, 0, 3278, 3264, 1, 0, 0, 0, 3278, 3271, 1, 0, 0, + 0, 3279, 445, 1, 0, 0, 0, 3280, 3285, 3, 1200, 600, 0, 3281, 3282, 5, 17, + 0, 0, 3282, 3284, 3, 1200, 600, 0, 3283, 3281, 1, 0, 0, 0, 3284, 3287, + 1, 0, 0, 0, 3285, 3283, 1, 0, 0, 0, 3285, 3286, 1, 0, 0, 0, 3286, 447, + 1, 0, 0, 0, 3287, 3285, 1, 0, 0, 0, 3288, 3290, 3, 450, 225, 0, 3289, 3291, + 3, 452, 226, 0, 3290, 3289, 1, 0, 0, 0, 3290, 3291, 1, 0, 0, 0, 3291, 449, + 1, 0, 0, 0, 3292, 3293, 5, 263, 0, 0, 3293, 3299, 5, 273, 0, 0, 3294, 3296, + 5, 134, 0, 0, 3295, 3297, 5, 273, 0, 0, 3296, 3295, 1, 0, 0, 0, 3296, 3297, + 1, 0, 0, 0, 3297, 3299, 1, 0, 0, 0, 3298, 3292, 1, 0, 0, 0, 3298, 3294, + 1, 0, 0, 0, 3299, 451, 1, 0, 0, 0, 3300, 3305, 3, 454, 227, 0, 3301, 3302, + 5, 17, 0, 0, 3302, 3304, 3, 454, 227, 0, 3303, 3301, 1, 0, 0, 0, 3304, + 3307, 1, 0, 0, 0, 3305, 3303, 1, 0, 0, 0, 3305, 3306, 1, 0, 0, 0, 3306, + 453, 1, 0, 0, 0, 3307, 3305, 1, 0, 0, 0, 3308, 3309, 5, 233, 0, 0, 3309, + 3321, 5, 217, 0, 0, 3310, 3311, 5, 233, 0, 0, 3311, 3321, 5, 289, 0, 0, + 3312, 3313, 5, 193, 0, 0, 3313, 3314, 5, 199, 0, 0, 3314, 3321, 3, 1200, + 600, 0, 3315, 3316, 5, 193, 0, 0, 3316, 3317, 5, 199, 0, 0, 3317, 3318, + 3, 1200, 600, 0, 3318, 3319, 3, 1200, 600, 0, 3319, 3321, 1, 0, 0, 0, 3320, + 3308, 1, 0, 0, 0, 3320, 3310, 1, 0, 0, 0, 3320, 3312, 1, 0, 0, 0, 3320, + 3315, 1, 0, 0, 0, 3321, 455, 1, 0, 0, 0, 3322, 3323, 5, 275, 0, 0, 3323, + 3324, 5, 268, 0, 0, 3324, 3326, 3, 858, 429, 0, 3325, 3327, 3, 486, 243, + 0, 3326, 3325, 1, 0, 0, 0, 3326, 3327, 1, 0, 0, 0, 3327, 457, 1, 0, 0, + 0, 3328, 3330, 5, 342, 0, 0, 3329, 3331, 5, 338, 0, 0, 3330, 3329, 1, 0, + 0, 0, 3330, 3331, 1, 0, 0, 0, 3331, 3332, 1, 0, 0, 0, 3332, 3334, 3, 858, + 429, 0, 3333, 3335, 3, 800, 400, 0, 3334, 3333, 1, 0, 0, 0, 3334, 3335, + 1, 0, 0, 0, 3335, 3336, 1, 0, 0, 0, 3336, 3337, 5, 102, 0, 0, 3337, 3338, + 3, 460, 230, 0, 3338, 3339, 5, 84, 0, 0, 3339, 3341, 3, 952, 476, 0, 3340, + 3342, 3, 462, 231, 0, 3341, 3340, 1, 0, 0, 0, 3342, 3343, 1, 0, 0, 0, 3343, + 3341, 1, 0, 0, 0, 3343, 3344, 1, 0, 0, 0, 3344, 459, 1, 0, 0, 0, 3345, + 3348, 3, 846, 423, 0, 3346, 3348, 3, 832, 416, 0, 3347, 3345, 1, 0, 0, + 0, 3347, 3346, 1, 0, 0, 0, 3348, 461, 1, 0, 0, 0, 3349, 3350, 5, 298, 0, + 0, 3350, 3352, 5, 206, 0, 0, 3351, 3353, 3, 470, 235, 0, 3352, 3351, 1, + 0, 0, 0, 3352, 3353, 1, 0, 0, 0, 3353, 3354, 1, 0, 0, 0, 3354, 3355, 5, + 299, 0, 0, 3355, 3378, 3, 464, 232, 0, 3356, 3357, 5, 298, 0, 0, 3357, + 3358, 5, 111, 0, 0, 3358, 3360, 5, 206, 0, 0, 3359, 3361, 3, 468, 234, + 0, 3360, 3359, 1, 0, 0, 0, 3360, 3361, 1, 0, 0, 0, 3361, 3363, 1, 0, 0, + 0, 3362, 3364, 3, 470, 235, 0, 3363, 3362, 1, 0, 0, 0, 3363, 3364, 1, 0, + 0, 0, 3364, 3365, 1, 0, 0, 0, 3365, 3366, 5, 299, 0, 0, 3366, 3378, 3, + 464, 232, 0, 3367, 3368, 5, 298, 0, 0, 3368, 3369, 5, 111, 0, 0, 3369, + 3370, 5, 206, 0, 0, 3370, 3371, 5, 60, 0, 0, 3371, 3373, 5, 260, 0, 0, + 3372, 3374, 3, 470, 235, 0, 3373, 3372, 1, 0, 0, 0, 3373, 3374, 1, 0, 0, + 0, 3374, 3375, 1, 0, 0, 0, 3375, 3376, 5, 299, 0, 0, 3376, 3378, 3, 464, + 232, 0, 3377, 3349, 1, 0, 0, 0, 3377, 3356, 1, 0, 0, 0, 3377, 3367, 1, + 0, 0, 0, 3378, 463, 1, 0, 0, 0, 3379, 3381, 5, 191, 0, 0, 3380, 3382, 3, + 694, 347, 0, 3381, 3380, 1, 0, 0, 0, 3381, 3382, 1, 0, 0, 0, 3382, 3383, + 1, 0, 0, 0, 3383, 3389, 3, 466, 233, 0, 3384, 3385, 5, 281, 0, 0, 3385, + 3386, 5, 257, 0, 0, 3386, 3389, 3, 490, 245, 0, 3387, 3389, 5, 156, 0, + 0, 3388, 3379, 1, 0, 0, 0, 3388, 3384, 1, 0, 0, 0, 3388, 3387, 1, 0, 0, + 0, 3389, 465, 1, 0, 0, 0, 3390, 3391, 5, 282, 0, 0, 3391, 3394, 3, 512, + 256, 0, 3392, 3394, 5, 249, 0, 0, 3393, 3390, 1, 0, 0, 0, 3393, 3392, 1, + 0, 0, 0, 3394, 467, 1, 0, 0, 0, 3395, 3396, 5, 60, 0, 0, 3396, 3397, 5, + 270, 0, 0, 3397, 469, 1, 0, 0, 0, 3398, 3399, 5, 112, 0, 0, 3399, 3400, + 3, 952, 476, 0, 3400, 471, 1, 0, 0, 0, 3401, 3402, 3, 1066, 533, 0, 3402, + 473, 1, 0, 0, 0, 3403, 3404, 3, 706, 353, 0, 3404, 475, 1, 0, 0, 0, 3405, + 3409, 3, 482, 241, 0, 3406, 3409, 3, 480, 240, 0, 3407, 3409, 3, 478, 239, + 0, 3408, 3405, 1, 0, 0, 0, 3408, 3406, 1, 0, 0, 0, 3408, 3407, 1, 0, 0, + 0, 3409, 477, 1, 0, 0, 0, 3410, 3411, 5, 281, 0, 0, 3411, 3413, 3, 518, + 259, 0, 3412, 3414, 3, 1066, 533, 0, 3413, 3412, 1, 0, 0, 0, 3413, 3414, + 1, 0, 0, 0, 3414, 3416, 1, 0, 0, 0, 3415, 3417, 3, 800, 400, 0, 3416, 3415, + 1, 0, 0, 0, 3416, 3417, 1, 0, 0, 0, 3417, 3419, 1, 0, 0, 0, 3418, 3420, + 3, 850, 425, 0, 3419, 3418, 1, 0, 0, 0, 3419, 3420, 1, 0, 0, 0, 3420, 3421, + 1, 0, 0, 0, 3421, 3422, 5, 257, 0, 0, 3422, 3424, 3, 490, 245, 0, 3423, + 3425, 3, 788, 394, 0, 3424, 3423, 1, 0, 0, 0, 3424, 3425, 1, 0, 0, 0, 3425, + 3427, 1, 0, 0, 0, 3426, 3428, 3, 486, 243, 0, 3427, 3426, 1, 0, 0, 0, 3427, + 3428, 1, 0, 0, 0, 3428, 3430, 1, 0, 0, 0, 3429, 3431, 3, 506, 253, 0, 3430, + 3429, 1, 0, 0, 0, 3430, 3431, 1, 0, 0, 0, 3431, 3433, 1, 0, 0, 0, 3432, + 3434, 3, 504, 252, 0, 3433, 3432, 1, 0, 0, 0, 3433, 3434, 1, 0, 0, 0, 3434, + 479, 1, 0, 0, 0, 3435, 3437, 5, 156, 0, 0, 3436, 3438, 5, 71, 0, 0, 3437, + 3436, 1, 0, 0, 0, 3437, 3438, 1, 0, 0, 0, 3438, 3439, 1, 0, 0, 0, 3439, + 3441, 3, 518, 259, 0, 3440, 3442, 3, 1066, 533, 0, 3441, 3440, 1, 0, 0, + 0, 3441, 3442, 1, 0, 0, 0, 3442, 3444, 1, 0, 0, 0, 3443, 3445, 3, 800, + 400, 0, 3444, 3443, 1, 0, 0, 0, 3444, 3445, 1, 0, 0, 0, 3445, 3447, 1, + 0, 0, 0, 3446, 3448, 3, 850, 425, 0, 3447, 3446, 1, 0, 0, 0, 3447, 3448, + 1, 0, 0, 0, 3448, 3450, 1, 0, 0, 0, 3449, 3451, 3, 486, 243, 0, 3450, 3449, + 1, 0, 0, 0, 3450, 3451, 1, 0, 0, 0, 3451, 3453, 1, 0, 0, 0, 3452, 3454, + 3, 506, 253, 0, 3453, 3452, 1, 0, 0, 0, 3453, 3454, 1, 0, 0, 0, 3454, 3456, + 1, 0, 0, 0, 3455, 3457, 3, 504, 252, 0, 3456, 3455, 1, 0, 0, 0, 3456, 3457, + 1, 0, 0, 0, 3457, 481, 1, 0, 0, 0, 3458, 3460, 3, 516, 258, 0, 3459, 3461, + 3, 694, 347, 0, 3460, 3459, 1, 0, 0, 0, 3460, 3461, 1, 0, 0, 0, 3461, 3462, + 1, 0, 0, 0, 3462, 3464, 3, 508, 254, 0, 3463, 3465, 3, 506, 253, 0, 3464, + 3463, 1, 0, 0, 0, 3464, 3465, 1, 0, 0, 0, 3465, 3467, 1, 0, 0, 0, 3466, + 3468, 3, 504, 252, 0, 3467, 3466, 1, 0, 0, 0, 3467, 3468, 1, 0, 0, 0, 3468, + 3496, 1, 0, 0, 0, 3469, 3471, 3, 516, 258, 0, 3470, 3472, 3, 694, 347, + 0, 3471, 3470, 1, 0, 0, 0, 3471, 3472, 1, 0, 0, 0, 3472, 3473, 1, 0, 0, + 0, 3473, 3474, 3, 498, 249, 0, 3474, 3476, 3, 484, 242, 0, 3475, 3477, + 3, 506, 253, 0, 3476, 3475, 1, 0, 0, 0, 3476, 3477, 1, 0, 0, 0, 3477, 3479, + 1, 0, 0, 0, 3478, 3480, 3, 504, 252, 0, 3479, 3478, 1, 0, 0, 0, 3479, 3480, + 1, 0, 0, 0, 3480, 3496, 1, 0, 0, 0, 3481, 3483, 3, 516, 258, 0, 3482, 3484, + 3, 694, 347, 0, 3483, 3482, 1, 0, 0, 0, 3483, 3484, 1, 0, 0, 0, 3484, 3485, + 1, 0, 0, 0, 3485, 3486, 5, 21, 0, 0, 3486, 3487, 3, 706, 353, 0, 3487, + 3488, 5, 22, 0, 0, 3488, 3490, 3, 484, 242, 0, 3489, 3491, 3, 506, 253, + 0, 3490, 3489, 1, 0, 0, 0, 3490, 3491, 1, 0, 0, 0, 3491, 3493, 1, 0, 0, + 0, 3492, 3494, 3, 504, 252, 0, 3493, 3492, 1, 0, 0, 0, 3493, 3494, 1, 0, + 0, 0, 3494, 3496, 1, 0, 0, 0, 3495, 3458, 1, 0, 0, 0, 3495, 3469, 1, 0, + 0, 0, 3495, 3481, 1, 0, 0, 0, 3496, 483, 1, 0, 0, 0, 3497, 3498, 5, 84, + 0, 0, 3498, 3500, 5, 340, 0, 0, 3499, 3501, 3, 488, 244, 0, 3500, 3499, + 1, 0, 0, 0, 3500, 3501, 1, 0, 0, 0, 3501, 3502, 1, 0, 0, 0, 3502, 3503, + 5, 161, 0, 0, 3503, 3517, 5, 341, 0, 0, 3504, 3505, 5, 84, 0, 0, 3505, + 3507, 5, 340, 0, 0, 3506, 3508, 3, 488, 244, 0, 3507, 3506, 1, 0, 0, 0, + 3507, 3508, 1, 0, 0, 0, 3508, 3509, 1, 0, 0, 0, 3509, 3510, 5, 161, 0, + 0, 3510, 3511, 5, 281, 0, 0, 3511, 3512, 5, 257, 0, 0, 3512, 3514, 3, 490, + 245, 0, 3513, 3515, 3, 486, 243, 0, 3514, 3513, 1, 0, 0, 0, 3514, 3515, + 1, 0, 0, 0, 3515, 3517, 1, 0, 0, 0, 3516, 3497, 1, 0, 0, 0, 3516, 3504, + 1, 0, 0, 0, 3517, 485, 1, 0, 0, 0, 3518, 3519, 5, 329, 0, 0, 3519, 3520, + 3, 952, 476, 0, 3520, 487, 1, 0, 0, 0, 3521, 3527, 3, 694, 347, 0, 3522, + 3523, 5, 84, 0, 0, 3523, 3524, 5, 278, 0, 0, 3524, 3525, 5, 148, 0, 0, + 3525, 3527, 3, 1200, 600, 0, 3526, 3521, 1, 0, 0, 0, 3526, 3522, 1, 0, + 0, 0, 3527, 489, 1, 0, 0, 0, 3528, 3533, 3, 492, 246, 0, 3529, 3530, 5, + 17, 0, 0, 3530, 3532, 3, 492, 246, 0, 3531, 3529, 1, 0, 0, 0, 3532, 3535, + 1, 0, 0, 0, 3533, 3531, 1, 0, 0, 0, 3533, 3534, 1, 0, 0, 0, 3534, 491, + 1, 0, 0, 0, 3535, 3533, 1, 0, 0, 0, 3536, 3539, 3, 494, 247, 0, 3537, 3539, + 3, 496, 248, 0, 3538, 3536, 1, 0, 0, 0, 3538, 3537, 1, 0, 0, 0, 3539, 493, + 1, 0, 0, 0, 3540, 3541, 3, 1106, 553, 0, 3541, 3542, 5, 1, 0, 0, 3542, + 3543, 3, 514, 257, 0, 3543, 495, 1, 0, 0, 0, 3544, 3545, 5, 21, 0, 0, 3545, + 3546, 3, 476, 238, 0, 3546, 3547, 5, 22, 0, 0, 3547, 497, 1, 0, 0, 0, 3548, + 3551, 3, 510, 255, 0, 3549, 3551, 3, 500, 250, 0, 3550, 3548, 1, 0, 0, + 0, 3550, 3549, 1, 0, 0, 0, 3551, 499, 1, 0, 0, 0, 3552, 3553, 5, 268, 0, + 0, 3553, 3554, 3, 502, 251, 0, 3554, 501, 1, 0, 0, 0, 3555, 3557, 3, 1198, + 599, 0, 3556, 3558, 3, 774, 387, 0, 3557, 3556, 1, 0, 0, 0, 3557, 3558, + 1, 0, 0, 0, 3558, 3564, 1, 0, 0, 0, 3559, 3561, 3, 796, 398, 0, 3560, 3562, + 3, 774, 387, 0, 3561, 3560, 1, 0, 0, 0, 3561, 3562, 1, 0, 0, 0, 3562, 3564, + 1, 0, 0, 0, 3563, 3555, 1, 0, 0, 0, 3563, 3559, 1, 0, 0, 0, 3564, 503, + 1, 0, 0, 0, 3565, 3566, 5, 299, 0, 0, 3566, 3567, 5, 246, 0, 0, 3567, 3582, + 3, 934, 467, 0, 3568, 3569, 5, 299, 0, 0, 3569, 3570, 5, 246, 0, 0, 3570, + 3571, 5, 104, 0, 0, 3571, 3572, 5, 124, 0, 0, 3572, 3582, 3, 934, 467, + 0, 3573, 3574, 5, 299, 0, 0, 3574, 3575, 5, 246, 0, 0, 3575, 3576, 5, 104, + 0, 0, 3576, 3577, 5, 124, 0, 0, 3577, 3578, 5, 58, 0, 0, 3578, 3579, 3, + 1200, 600, 0, 3579, 3580, 3, 934, 467, 0, 3580, 3582, 1, 0, 0, 0, 3581, + 3565, 1, 0, 0, 0, 3581, 3568, 1, 0, 0, 0, 3581, 3573, 1, 0, 0, 0, 3582, + 505, 1, 0, 0, 0, 3583, 3584, 5, 339, 0, 0, 3584, 3585, 3, 808, 404, 0, + 3585, 507, 1, 0, 0, 0, 3586, 3589, 3, 510, 255, 0, 3587, 3589, 3, 706, + 353, 0, 3588, 3586, 1, 0, 0, 0, 3588, 3587, 1, 0, 0, 0, 3589, 509, 1, 0, + 0, 0, 3590, 3591, 5, 282, 0, 0, 3591, 3596, 3, 512, 256, 0, 3592, 3593, + 5, 17, 0, 0, 3593, 3595, 3, 512, 256, 0, 3594, 3592, 1, 0, 0, 0, 3595, + 3598, 1, 0, 0, 0, 3596, 3594, 1, 0, 0, 0, 3596, 3597, 1, 0, 0, 0, 3597, + 511, 1, 0, 0, 0, 3598, 3596, 1, 0, 0, 0, 3599, 3600, 5, 21, 0, 0, 3600, + 3605, 3, 514, 257, 0, 3601, 3602, 5, 17, 0, 0, 3602, 3604, 3, 514, 257, + 0, 3603, 3601, 1, 0, 0, 0, 3604, 3607, 1, 0, 0, 0, 3605, 3603, 1, 0, 0, + 0, 3605, 3606, 1, 0, 0, 0, 3606, 3608, 1, 0, 0, 0, 3607, 3605, 1, 0, 0, + 0, 3608, 3609, 5, 22, 0, 0, 3609, 513, 1, 0, 0, 0, 3610, 3613, 3, 952, + 476, 0, 3611, 3613, 5, 324, 0, 0, 3612, 3610, 1, 0, 0, 0, 3612, 3611, 1, + 0, 0, 0, 3613, 515, 1, 0, 0, 0, 3614, 3616, 5, 191, 0, 0, 3615, 3617, 3, + 522, 261, 0, 3616, 3615, 1, 0, 0, 0, 3616, 3617, 1, 0, 0, 0, 3617, 3619, + 1, 0, 0, 0, 3618, 3620, 3, 520, 260, 0, 3619, 3618, 1, 0, 0, 0, 3619, 3620, + 1, 0, 0, 0, 3620, 3621, 1, 0, 0, 0, 3621, 3623, 3, 518, 259, 0, 3622, 3624, + 3, 1066, 533, 0, 3623, 3622, 1, 0, 0, 0, 3623, 3624, 1, 0, 0, 0, 3624, + 517, 1, 0, 0, 0, 3625, 3628, 3, 1106, 553, 0, 3626, 3628, 3, 860, 430, + 0, 3627, 3625, 1, 0, 0, 0, 3627, 3626, 1, 0, 0, 0, 3628, 519, 1, 0, 0, + 0, 3629, 3630, 5, 338, 0, 0, 3630, 521, 1, 0, 0, 0, 3631, 3632, 5, 113, + 0, 0, 3632, 3641, 5, 313, 0, 0, 3633, 3641, 5, 313, 0, 0, 3634, 3635, 5, + 113, 0, 0, 3635, 3641, 5, 93, 0, 0, 3636, 3641, 5, 93, 0, 0, 3637, 3638, + 5, 113, 0, 0, 3638, 3641, 5, 281, 0, 0, 3639, 3641, 5, 281, 0, 0, 3640, + 3631, 1, 0, 0, 0, 3640, 3633, 1, 0, 0, 0, 3640, 3634, 1, 0, 0, 0, 3640, + 3636, 1, 0, 0, 0, 3640, 3637, 1, 0, 0, 0, 3640, 3639, 1, 0, 0, 0, 3641, + 523, 1, 0, 0, 0, 3642, 3643, 5, 127, 0, 0, 3643, 3645, 3, 704, 352, 0, + 3644, 3646, 3, 702, 351, 0, 3645, 3644, 1, 0, 0, 0, 3645, 3646, 1, 0, 0, + 0, 3646, 3647, 1, 0, 0, 0, 3647, 3648, 3, 858, 429, 0, 3648, 3649, 3, 586, + 293, 0, 3649, 3707, 1, 0, 0, 0, 3650, 3651, 5, 127, 0, 0, 3651, 3653, 3, + 584, 292, 0, 3652, 3654, 3, 702, 351, 0, 3653, 3652, 1, 0, 0, 0, 3653, + 3654, 1, 0, 0, 0, 3654, 3655, 1, 0, 0, 0, 3655, 3656, 3, 1198, 599, 0, + 3656, 3657, 3, 586, 293, 0, 3657, 3707, 1, 0, 0, 0, 3658, 3659, 5, 127, + 0, 0, 3659, 3661, 3, 580, 290, 0, 3660, 3662, 3, 702, 351, 0, 3661, 3660, + 1, 0, 0, 0, 3661, 3662, 1, 0, 0, 0, 3662, 3663, 1, 0, 0, 0, 3663, 3664, + 3, 1198, 599, 0, 3664, 3665, 3, 586, 293, 0, 3665, 3707, 1, 0, 0, 0, 3666, + 3667, 5, 127, 0, 0, 3667, 3669, 3, 580, 290, 0, 3668, 3670, 3, 702, 351, + 0, 3669, 3668, 1, 0, 0, 0, 3669, 3670, 1, 0, 0, 0, 3670, 3671, 1, 0, 0, + 0, 3671, 3672, 3, 586, 293, 0, 3672, 3707, 1, 0, 0, 0, 3673, 3674, 5, 127, + 0, 0, 3674, 3675, 5, 227, 0, 0, 3675, 3677, 5, 244, 0, 0, 3676, 3678, 3, + 702, 351, 0, 3677, 3676, 1, 0, 0, 0, 3677, 3678, 1, 0, 0, 0, 3678, 3679, + 1, 0, 0, 0, 3679, 3680, 5, 84, 0, 0, 3680, 3681, 3, 572, 286, 0, 3681, + 3682, 5, 84, 0, 0, 3682, 3683, 3, 1200, 600, 0, 3683, 3684, 3, 1198, 599, + 0, 3684, 3707, 1, 0, 0, 0, 3685, 3686, 5, 127, 0, 0, 3686, 3687, 5, 249, + 0, 0, 3687, 3688, 5, 123, 0, 0, 3688, 3690, 5, 224, 0, 0, 3689, 3691, 3, + 702, 351, 0, 3690, 3689, 1, 0, 0, 0, 3690, 3691, 1, 0, 0, 0, 3691, 3692, + 1, 0, 0, 0, 3692, 3693, 3, 1200, 600, 0, 3693, 3694, 5, 84, 0, 0, 3694, + 3695, 3, 1198, 599, 0, 3695, 3696, 3, 564, 282, 0, 3696, 3707, 1, 0, 0, + 0, 3697, 3698, 5, 127, 0, 0, 3698, 3699, 5, 57, 0, 0, 3699, 3700, 5, 249, + 0, 0, 3700, 3701, 5, 123, 0, 0, 3701, 3702, 5, 223, 0, 0, 3702, 3703, 5, + 84, 0, 0, 3703, 3704, 3, 1198, 599, 0, 3704, 3705, 3, 566, 283, 0, 3705, + 3707, 1, 0, 0, 0, 3706, 3642, 1, 0, 0, 0, 3706, 3650, 1, 0, 0, 0, 3706, + 3658, 1, 0, 0, 0, 3706, 3666, 1, 0, 0, 0, 3706, 3673, 1, 0, 0, 0, 3706, + 3685, 1, 0, 0, 0, 3706, 3697, 1, 0, 0, 0, 3707, 525, 1, 0, 0, 0, 3708, + 3710, 5, 129, 0, 0, 3709, 3711, 3, 696, 348, 0, 3710, 3709, 1, 0, 0, 0, + 3710, 3711, 1, 0, 0, 0, 3711, 3713, 1, 0, 0, 0, 3712, 3714, 3, 560, 280, + 0, 3713, 3712, 1, 0, 0, 0, 3713, 3714, 1, 0, 0, 0, 3714, 527, 1, 0, 0, + 0, 3715, 3716, 5, 132, 0, 0, 3716, 3718, 3, 952, 476, 0, 3717, 3719, 3, + 558, 279, 0, 3718, 3717, 1, 0, 0, 0, 3718, 3719, 1, 0, 0, 0, 3719, 529, + 1, 0, 0, 0, 3720, 3721, 5, 200, 0, 0, 3721, 3722, 5, 152, 0, 0, 3722, 3723, + 3, 556, 278, 0, 3723, 3725, 3, 548, 274, 0, 3724, 3726, 3, 550, 275, 0, + 3725, 3724, 1, 0, 0, 0, 3725, 3726, 1, 0, 0, 0, 3726, 3728, 1, 0, 0, 0, + 3727, 3729, 3, 546, 273, 0, 3728, 3727, 1, 0, 0, 0, 3728, 3729, 1, 0, 0, + 0, 3729, 3731, 1, 0, 0, 0, 3730, 3732, 3, 1172, 586, 0, 3731, 3730, 1, + 0, 0, 0, 3731, 3732, 1, 0, 0, 0, 3732, 3734, 1, 0, 0, 0, 3733, 3735, 3, + 818, 409, 0, 3734, 3733, 1, 0, 0, 0, 3734, 3735, 1, 0, 0, 0, 3735, 3737, + 1, 0, 0, 0, 3736, 3738, 3, 544, 272, 0, 3737, 3736, 1, 0, 0, 0, 3737, 3738, + 1, 0, 0, 0, 3738, 3740, 1, 0, 0, 0, 3739, 3741, 3, 696, 348, 0, 3740, 3739, + 1, 0, 0, 0, 3740, 3741, 1, 0, 0, 0, 3741, 3742, 1, 0, 0, 0, 3742, 3744, + 3, 542, 271, 0, 3743, 3745, 3, 538, 269, 0, 3744, 3743, 1, 0, 0, 0, 3744, + 3745, 1, 0, 0, 0, 3745, 531, 1, 0, 0, 0, 3746, 3747, 5, 140, 0, 0, 3747, + 3748, 5, 152, 0, 0, 3748, 3749, 5, 338, 0, 0, 3749, 3750, 3, 858, 429, + 0, 3750, 3751, 5, 71, 0, 0, 3751, 3752, 3, 534, 267, 0, 3752, 533, 1, 0, + 0, 0, 3753, 3759, 3, 536, 268, 0, 3754, 3755, 5, 100, 0, 0, 3755, 3756, + 5, 57, 0, 0, 3756, 3758, 3, 536, 268, 0, 3757, 3754, 1, 0, 0, 0, 3758, + 3761, 1, 0, 0, 0, 3759, 3757, 1, 0, 0, 0, 3759, 3760, 1, 0, 0, 0, 3760, + 535, 1, 0, 0, 0, 3761, 3759, 1, 0, 0, 0, 3762, 3764, 3, 858, 429, 0, 3763, + 3765, 3, 848, 424, 0, 3764, 3763, 1, 0, 0, 0, 3764, 3765, 1, 0, 0, 0, 3765, + 3767, 1, 0, 0, 0, 3766, 3768, 3, 774, 387, 0, 3767, 3766, 1, 0, 0, 0, 3767, + 3768, 1, 0, 0, 0, 3768, 537, 1, 0, 0, 0, 3769, 3770, 3, 540, 270, 0, 3770, + 3771, 3, 396, 198, 0, 3771, 3775, 1, 0, 0, 0, 3772, 3775, 3, 540, 270, + 0, 3773, 3775, 3, 396, 198, 0, 3774, 3769, 1, 0, 0, 0, 3774, 3772, 1, 0, + 0, 0, 3774, 3773, 1, 0, 0, 0, 3775, 539, 1, 0, 0, 0, 3776, 3777, 5, 104, + 0, 0, 3777, 3778, 5, 312, 0, 0, 3778, 3780, 5, 144, 0, 0, 3779, 3781, 3, + 550, 275, 0, 3780, 3779, 1, 0, 0, 0, 3780, 3781, 1, 0, 0, 0, 3781, 541, + 1, 0, 0, 0, 3782, 3783, 5, 71, 0, 0, 3783, 3784, 5, 172, 0, 0, 3784, 3785, + 3, 1034, 517, 0, 3785, 543, 1, 0, 0, 0, 3786, 3787, 5, 142, 0, 0, 3787, + 3788, 5, 60, 0, 0, 3788, 3793, 3, 952, 476, 0, 3789, 3790, 5, 17, 0, 0, + 3790, 3792, 3, 952, 476, 0, 3791, 3789, 1, 0, 0, 0, 3792, 3795, 1, 0, 0, + 0, 3793, 3791, 1, 0, 0, 0, 3793, 3794, 1, 0, 0, 0, 3794, 545, 1, 0, 0, + 0, 3795, 3793, 1, 0, 0, 0, 3796, 3798, 5, 220, 0, 0, 3797, 3796, 1, 0, + 0, 0, 3797, 3798, 1, 0, 0, 0, 3798, 3799, 1, 0, 0, 0, 3799, 3800, 5, 221, + 0, 0, 3800, 3801, 5, 21, 0, 0, 3801, 3802, 3, 952, 476, 0, 3802, 3803, + 5, 22, 0, 0, 3803, 547, 1, 0, 0, 0, 3804, 3805, 5, 271, 0, 0, 3805, 3806, + 5, 268, 0, 0, 3806, 3812, 3, 858, 429, 0, 3807, 3808, 5, 272, 0, 0, 3808, + 3809, 5, 268, 0, 0, 3809, 3812, 3, 858, 429, 0, 3810, 3812, 3, 858, 429, + 0, 3811, 3804, 1, 0, 0, 0, 3811, 3807, 1, 0, 0, 0, 3811, 3810, 1, 0, 0, + 0, 3812, 549, 1, 0, 0, 0, 3813, 3825, 5, 21, 0, 0, 3814, 3819, 3, 552, + 276, 0, 3815, 3816, 5, 17, 0, 0, 3816, 3818, 3, 552, 276, 0, 3817, 3815, + 1, 0, 0, 0, 3818, 3821, 1, 0, 0, 0, 3819, 3817, 1, 0, 0, 0, 3819, 3820, + 1, 0, 0, 0, 3820, 3823, 1, 0, 0, 0, 3821, 3819, 1, 0, 0, 0, 3822, 3824, + 5, 17, 0, 0, 3823, 3822, 1, 0, 0, 0, 3823, 3824, 1, 0, 0, 0, 3824, 3826, + 1, 0, 0, 0, 3825, 3814, 1, 0, 0, 0, 3825, 3826, 1, 0, 0, 0, 3826, 3827, + 1, 0, 0, 0, 3827, 3828, 5, 22, 0, 0, 3828, 551, 1, 0, 0, 0, 3829, 3832, + 3, 604, 302, 0, 3830, 3832, 3, 554, 277, 0, 3831, 3829, 1, 0, 0, 0, 3831, + 3830, 1, 0, 0, 0, 3832, 553, 1, 0, 0, 0, 3833, 3840, 3, 672, 336, 0, 3834, + 3840, 3, 678, 339, 0, 3835, 3836, 3, 1200, 600, 0, 3836, 3837, 3, 1200, + 600, 0, 3837, 3838, 3, 678, 339, 0, 3838, 3840, 1, 0, 0, 0, 3839, 3833, + 1, 0, 0, 0, 3839, 3834, 1, 0, 0, 0, 3839, 3835, 1, 0, 0, 0, 3840, 555, + 1, 0, 0, 0, 3841, 3842, 7, 12, 0, 0, 3842, 557, 1, 0, 0, 0, 3843, 3844, + 5, 58, 0, 0, 3844, 3845, 3, 1244, 622, 0, 3845, 559, 1, 0, 0, 0, 3846, + 3851, 3, 562, 281, 0, 3847, 3848, 5, 17, 0, 0, 3848, 3850, 3, 562, 281, + 0, 3849, 3847, 1, 0, 0, 0, 3850, 3853, 1, 0, 0, 0, 3851, 3849, 1, 0, 0, + 0, 3851, 3852, 1, 0, 0, 0, 3852, 561, 1, 0, 0, 0, 3853, 3851, 1, 0, 0, + 0, 3854, 3856, 3, 858, 429, 0, 3855, 3857, 3, 694, 347, 0, 3856, 3855, + 1, 0, 0, 0, 3856, 3857, 1, 0, 0, 0, 3857, 563, 1, 0, 0, 0, 3858, 3863, + 3, 566, 283, 0, 3859, 3860, 5, 17, 0, 0, 3860, 3862, 3, 566, 283, 0, 3861, + 3859, 1, 0, 0, 0, 3862, 3865, 1, 0, 0, 0, 3863, 3861, 1, 0, 0, 0, 3863, + 3864, 1, 0, 0, 0, 3864, 565, 1, 0, 0, 0, 3865, 3863, 1, 0, 0, 0, 3866, + 3886, 3, 568, 284, 0, 3867, 3868, 5, 173, 0, 0, 3868, 3869, 5, 102, 0, + 0, 3869, 3870, 5, 21, 0, 0, 3870, 3871, 3, 952, 476, 0, 3871, 3872, 5, + 22, 0, 0, 3872, 3886, 1, 0, 0, 0, 3873, 3874, 5, 247, 0, 0, 3874, 3875, + 5, 71, 0, 0, 3875, 3876, 5, 21, 0, 0, 3876, 3877, 3, 570, 285, 0, 3877, + 3878, 5, 22, 0, 0, 3878, 3886, 1, 0, 0, 0, 3879, 3880, 5, 247, 0, 0, 3880, + 3881, 5, 71, 0, 0, 3881, 3886, 5, 57, 0, 0, 3882, 3883, 5, 237, 0, 0, 3883, + 3884, 5, 331, 0, 0, 3884, 3886, 3, 1200, 600, 0, 3885, 3866, 1, 0, 0, 0, + 3885, 3867, 1, 0, 0, 0, 3885, 3873, 1, 0, 0, 0, 3885, 3879, 1, 0, 0, 0, + 3885, 3882, 1, 0, 0, 0, 3886, 567, 1, 0, 0, 0, 3887, 3888, 5, 180, 0, 0, + 3888, 3889, 5, 331, 0, 0, 3889, 3890, 5, 21, 0, 0, 3890, 3891, 3, 570, + 285, 0, 3891, 3892, 5, 22, 0, 0, 3892, 569, 1, 0, 0, 0, 3893, 3898, 3, + 1174, 587, 0, 3894, 3895, 5, 17, 0, 0, 3895, 3897, 3, 1174, 587, 0, 3896, + 3894, 1, 0, 0, 0, 3897, 3900, 1, 0, 0, 0, 3898, 3896, 1, 0, 0, 0, 3898, + 3899, 1, 0, 0, 0, 3899, 571, 1, 0, 0, 0, 3900, 3898, 1, 0, 0, 0, 3901, + 3906, 3, 574, 287, 0, 3902, 3903, 5, 17, 0, 0, 3903, 3905, 3, 574, 287, + 0, 3904, 3902, 1, 0, 0, 0, 3905, 3908, 1, 0, 0, 0, 3906, 3904, 1, 0, 0, + 0, 3906, 3907, 1, 0, 0, 0, 3907, 573, 1, 0, 0, 0, 3908, 3906, 1, 0, 0, + 0, 3909, 3911, 3, 578, 289, 0, 3910, 3912, 3, 576, 288, 0, 3911, 3910, + 1, 0, 0, 0, 3911, 3912, 1, 0, 0, 0, 3912, 575, 1, 0, 0, 0, 3913, 3914, + 5, 21, 0, 0, 3914, 3915, 3, 912, 456, 0, 3915, 3916, 5, 22, 0, 0, 3916, + 577, 1, 0, 0, 0, 3917, 3920, 3, 1200, 600, 0, 3918, 3920, 5, 95, 0, 0, + 3919, 3917, 1, 0, 0, 0, 3919, 3918, 1, 0, 0, 0, 3920, 579, 1, 0, 0, 0, + 3921, 3922, 3, 582, 291, 0, 3922, 581, 1, 0, 0, 0, 3923, 3924, 7, 13, 0, + 0, 3924, 583, 1, 0, 0, 0, 3925, 3926, 5, 125, 0, 0, 3926, 3945, 5, 178, + 0, 0, 3927, 3928, 5, 130, 0, 0, 3928, 3945, 5, 284, 0, 0, 3929, 3945, 5, + 146, 0, 0, 3930, 3945, 5, 147, 0, 0, 3931, 3945, 5, 153, 0, 0, 3932, 3933, + 5, 171, 0, 0, 3933, 3945, 3, 704, 352, 0, 3934, 3935, 5, 171, 0, 0, 3935, + 3945, 5, 252, 0, 0, 3936, 3945, 5, 178, 0, 0, 3937, 3945, 5, 188, 0, 0, + 3938, 3939, 5, 207, 0, 0, 3939, 3945, 5, 284, 0, 0, 3940, 3945, 5, 215, + 0, 0, 3941, 3945, 5, 229, 0, 0, 3942, 3945, 5, 252, 0, 0, 3943, 3945, 5, + 284, 0, 0, 3944, 3925, 1, 0, 0, 0, 3944, 3927, 1, 0, 0, 0, 3944, 3929, + 1, 0, 0, 0, 3944, 3930, 1, 0, 0, 0, 3944, 3931, 1, 0, 0, 0, 3944, 3932, + 1, 0, 0, 0, 3944, 3934, 1, 0, 0, 0, 3944, 3936, 1, 0, 0, 0, 3944, 3937, + 1, 0, 0, 0, 3944, 3938, 1, 0, 0, 0, 3944, 3940, 1, 0, 0, 0, 3944, 3941, + 1, 0, 0, 0, 3944, 3942, 1, 0, 0, 0, 3944, 3943, 1, 0, 0, 0, 3945, 585, + 1, 0, 0, 0, 3946, 3951, 3, 588, 294, 0, 3947, 3948, 5, 17, 0, 0, 3948, + 3950, 3, 588, 294, 0, 3949, 3947, 1, 0, 0, 0, 3950, 3953, 1, 0, 0, 0, 3951, + 3949, 1, 0, 0, 0, 3951, 3952, 1, 0, 0, 0, 3952, 587, 1, 0, 0, 0, 3953, + 3951, 1, 0, 0, 0, 3954, 3955, 5, 257, 0, 0, 3955, 3956, 5, 85, 0, 0, 3956, + 4148, 3, 1034, 517, 0, 3957, 3958, 5, 257, 0, 0, 3958, 3959, 5, 58, 0, + 0, 3959, 4148, 3, 700, 350, 0, 3960, 3961, 5, 126, 0, 0, 3961, 4148, 3, + 678, 339, 0, 3962, 3963, 5, 126, 0, 0, 3963, 4148, 3, 672, 336, 0, 3964, + 3965, 5, 126, 0, 0, 3965, 3967, 5, 148, 0, 0, 3966, 3968, 3, 670, 335, + 0, 3967, 3966, 1, 0, 0, 0, 3967, 3968, 1, 0, 0, 0, 3968, 3969, 1, 0, 0, + 0, 3969, 3970, 3, 1200, 600, 0, 3970, 3971, 3, 668, 334, 0, 3971, 4148, + 1, 0, 0, 0, 3972, 3973, 5, 162, 0, 0, 3973, 3975, 5, 148, 0, 0, 3974, 3976, + 3, 702, 351, 0, 3975, 3974, 1, 0, 0, 0, 3975, 3976, 1, 0, 0, 0, 3976, 3977, + 1, 0, 0, 0, 3977, 4148, 3, 1200, 600, 0, 3978, 3979, 5, 162, 0, 0, 3979, + 3980, 5, 225, 0, 0, 3980, 3982, 5, 195, 0, 0, 3981, 3983, 3, 702, 351, + 0, 3982, 3981, 1, 0, 0, 0, 3982, 3983, 1, 0, 0, 0, 3983, 4148, 1, 0, 0, + 0, 3984, 3985, 5, 127, 0, 0, 3985, 3987, 5, 148, 0, 0, 3986, 3988, 3, 702, + 351, 0, 3987, 3986, 1, 0, 0, 0, 3987, 3988, 1, 0, 0, 0, 3988, 3989, 1, + 0, 0, 0, 3989, 3990, 3, 1200, 600, 0, 3990, 3991, 3, 698, 349, 0, 3991, + 4148, 1, 0, 0, 0, 3992, 3993, 5, 127, 0, 0, 3993, 3995, 5, 148, 0, 0, 3994, + 3996, 3, 702, 351, 0, 3995, 3994, 1, 0, 0, 0, 3995, 3996, 1, 0, 0, 0, 3996, + 3997, 1, 0, 0, 0, 3997, 3998, 3, 1200, 600, 0, 3998, 3999, 5, 257, 0, 0, + 3999, 4000, 5, 85, 0, 0, 4000, 4001, 3, 1034, 517, 0, 4001, 4148, 1, 0, + 0, 0, 4002, 4003, 5, 126, 0, 0, 4003, 4005, 5, 143, 0, 0, 4004, 4006, 3, + 670, 335, 0, 4005, 4004, 1, 0, 0, 0, 4005, 4006, 1, 0, 0, 0, 4006, 4007, + 1, 0, 0, 0, 4007, 4009, 3, 604, 302, 0, 4008, 4010, 3, 602, 301, 0, 4009, + 4008, 1, 0, 0, 0, 4009, 4010, 1, 0, 0, 0, 4010, 4012, 1, 0, 0, 0, 4011, + 4013, 3, 600, 300, 0, 4012, 4011, 1, 0, 0, 0, 4012, 4013, 1, 0, 0, 0, 4013, + 4148, 1, 0, 0, 0, 4014, 4015, 5, 162, 0, 0, 4015, 4017, 5, 143, 0, 0, 4016, + 4018, 3, 702, 351, 0, 4017, 4016, 1, 0, 0, 0, 4017, 4018, 1, 0, 0, 0, 4018, + 4019, 1, 0, 0, 0, 4019, 4148, 3, 1200, 600, 0, 4020, 4021, 5, 237, 0, 0, + 4021, 4023, 5, 143, 0, 0, 4022, 4024, 3, 702, 351, 0, 4023, 4022, 1, 0, + 0, 0, 4023, 4024, 1, 0, 0, 0, 4024, 4025, 1, 0, 0, 0, 4025, 4026, 3, 1200, + 600, 0, 4026, 4027, 5, 331, 0, 0, 4027, 4028, 3, 1200, 600, 0, 4028, 4148, + 1, 0, 0, 0, 4029, 4030, 5, 127, 0, 0, 4030, 4032, 5, 143, 0, 0, 4031, 4033, + 3, 702, 351, 0, 4032, 4031, 1, 0, 0, 0, 4032, 4033, 1, 0, 0, 0, 4033, 4034, + 1, 0, 0, 0, 4034, 4035, 3, 1200, 600, 0, 4035, 4036, 5, 257, 0, 0, 4036, + 4037, 5, 152, 0, 0, 4037, 4038, 5, 276, 0, 0, 4038, 4039, 3, 662, 331, + 0, 4039, 4148, 1, 0, 0, 0, 4040, 4041, 5, 127, 0, 0, 4041, 4043, 5, 143, + 0, 0, 4042, 4044, 3, 702, 351, 0, 4043, 4042, 1, 0, 0, 0, 4043, 4044, 1, + 0, 0, 0, 4044, 4045, 1, 0, 0, 0, 4045, 4046, 3, 1200, 600, 0, 4046, 4047, + 5, 257, 0, 0, 4047, 4048, 5, 85, 0, 0, 4048, 4049, 3, 1034, 517, 0, 4049, + 4148, 1, 0, 0, 0, 4050, 4051, 5, 127, 0, 0, 4051, 4053, 5, 143, 0, 0, 4052, + 4054, 3, 702, 351, 0, 4053, 4052, 1, 0, 0, 0, 4053, 4054, 1, 0, 0, 0, 4054, + 4055, 1, 0, 0, 0, 4055, 4056, 3, 1200, 600, 0, 4056, 4057, 5, 257, 0, 0, + 4057, 4058, 5, 324, 0, 0, 4058, 4059, 3, 952, 476, 0, 4059, 4148, 1, 0, + 0, 0, 4060, 4061, 5, 127, 0, 0, 4061, 4063, 5, 143, 0, 0, 4062, 4064, 3, + 702, 351, 0, 4063, 4062, 1, 0, 0, 0, 4063, 4064, 1, 0, 0, 0, 4064, 4065, + 1, 0, 0, 0, 4065, 4066, 3, 1200, 600, 0, 4066, 4067, 5, 162, 0, 0, 4067, + 4068, 5, 324, 0, 0, 4068, 4148, 1, 0, 0, 0, 4069, 4070, 5, 127, 0, 0, 4070, + 4072, 5, 143, 0, 0, 4071, 4073, 3, 702, 351, 0, 4072, 4071, 1, 0, 0, 0, + 4072, 4073, 1, 0, 0, 0, 4073, 4074, 1, 0, 0, 0, 4074, 4075, 3, 1200, 600, + 0, 4075, 4076, 5, 162, 0, 0, 4076, 4077, 5, 111, 0, 0, 4077, 4078, 5, 80, + 0, 0, 4078, 4148, 1, 0, 0, 0, 4079, 4080, 5, 127, 0, 0, 4080, 4082, 5, + 143, 0, 0, 4081, 4083, 3, 702, 351, 0, 4082, 4081, 1, 0, 0, 0, 4082, 4083, + 1, 0, 0, 0, 4083, 4084, 1, 0, 0, 0, 4084, 4085, 3, 1200, 600, 0, 4085, + 4086, 5, 162, 0, 0, 4086, 4087, 5, 179, 0, 0, 4087, 4148, 1, 0, 0, 0, 4088, + 4089, 5, 237, 0, 0, 4089, 4090, 5, 331, 0, 0, 4090, 4148, 3, 1198, 599, + 0, 4091, 4092, 5, 257, 0, 0, 4092, 4093, 5, 324, 0, 0, 4093, 4148, 3, 1172, + 586, 0, 4094, 4095, 5, 126, 0, 0, 4095, 4096, 5, 249, 0, 0, 4096, 4097, + 5, 157, 0, 0, 4097, 4099, 5, 224, 0, 0, 4098, 4100, 3, 670, 335, 0, 4099, + 4098, 1, 0, 0, 0, 4099, 4100, 1, 0, 0, 0, 4100, 4101, 1, 0, 0, 0, 4101, + 4102, 5, 21, 0, 0, 4102, 4103, 3, 952, 476, 0, 4103, 4104, 5, 22, 0, 0, + 4104, 4148, 1, 0, 0, 0, 4105, 4106, 5, 93, 0, 0, 4106, 4107, 5, 249, 0, + 0, 4107, 4108, 5, 157, 0, 0, 4108, 4110, 5, 224, 0, 0, 4109, 4111, 3, 702, + 351, 0, 4110, 4109, 1, 0, 0, 0, 4110, 4111, 1, 0, 0, 0, 4111, 4112, 1, + 0, 0, 0, 4112, 4113, 5, 21, 0, 0, 4113, 4114, 3, 952, 476, 0, 4114, 4115, + 5, 22, 0, 0, 4115, 4148, 1, 0, 0, 0, 4116, 4117, 5, 162, 0, 0, 4117, 4118, + 5, 249, 0, 0, 4118, 4119, 5, 157, 0, 0, 4119, 4121, 5, 224, 0, 0, 4120, + 4122, 3, 702, 351, 0, 4121, 4120, 1, 0, 0, 0, 4121, 4122, 1, 0, 0, 0, 4122, + 4148, 1, 0, 0, 0, 4123, 4124, 5, 127, 0, 0, 4124, 4126, 3, 596, 298, 0, + 4125, 4127, 3, 702, 351, 0, 4126, 4125, 1, 0, 0, 0, 4126, 4127, 1, 0, 0, + 0, 4127, 4128, 1, 0, 0, 0, 4128, 4129, 3, 1200, 600, 0, 4129, 4130, 3, + 588, 294, 0, 4130, 4148, 1, 0, 0, 0, 4131, 4132, 5, 126, 0, 0, 4132, 4134, + 3, 596, 298, 0, 4133, 4135, 3, 670, 335, 0, 4134, 4133, 1, 0, 0, 0, 4134, + 4135, 1, 0, 0, 0, 4135, 4136, 1, 0, 0, 0, 4136, 4137, 3, 1200, 600, 0, + 4137, 4148, 1, 0, 0, 0, 4138, 4139, 5, 162, 0, 0, 4139, 4141, 3, 596, 298, + 0, 4140, 4142, 3, 702, 351, 0, 4141, 4140, 1, 0, 0, 0, 4141, 4142, 1, 0, + 0, 0, 4142, 4143, 1, 0, 0, 0, 4143, 4144, 3, 1200, 600, 0, 4144, 4148, + 1, 0, 0, 0, 4145, 4148, 3, 592, 296, 0, 4146, 4148, 3, 590, 295, 0, 4147, + 3954, 1, 0, 0, 0, 4147, 3957, 1, 0, 0, 0, 4147, 3960, 1, 0, 0, 0, 4147, + 3962, 1, 0, 0, 0, 4147, 3964, 1, 0, 0, 0, 4147, 3972, 1, 0, 0, 0, 4147, + 3978, 1, 0, 0, 0, 4147, 3984, 1, 0, 0, 0, 4147, 3992, 1, 0, 0, 0, 4147, + 4002, 1, 0, 0, 0, 4147, 4014, 1, 0, 0, 0, 4147, 4020, 1, 0, 0, 0, 4147, + 4029, 1, 0, 0, 0, 4147, 4040, 1, 0, 0, 0, 4147, 4050, 1, 0, 0, 0, 4147, + 4060, 1, 0, 0, 0, 4147, 4069, 1, 0, 0, 0, 4147, 4079, 1, 0, 0, 0, 4147, + 4088, 1, 0, 0, 0, 4147, 4091, 1, 0, 0, 0, 4147, 4094, 1, 0, 0, 0, 4147, + 4105, 1, 0, 0, 0, 4147, 4116, 1, 0, 0, 0, 4147, 4123, 1, 0, 0, 0, 4147, + 4131, 1, 0, 0, 0, 4147, 4138, 1, 0, 0, 0, 4147, 4145, 1, 0, 0, 0, 4147, + 4146, 1, 0, 0, 0, 4148, 589, 1, 0, 0, 0, 4149, 4150, 5, 257, 0, 0, 4150, + 4151, 5, 84, 0, 0, 4151, 4152, 5, 156, 0, 0, 4152, 4153, 3, 688, 344, 0, + 4153, 591, 1, 0, 0, 0, 4154, 4155, 5, 127, 0, 0, 4155, 4157, 5, 143, 0, + 0, 4156, 4158, 3, 702, 351, 0, 4157, 4156, 1, 0, 0, 0, 4157, 4158, 1, 0, + 0, 0, 4158, 4159, 1, 0, 0, 0, 4159, 4160, 3, 1200, 600, 0, 4160, 4162, + 3, 648, 324, 0, 4161, 4163, 3, 666, 333, 0, 4162, 4161, 1, 0, 0, 0, 4162, + 4163, 1, 0, 0, 0, 4163, 4165, 1, 0, 0, 0, 4164, 4166, 3, 594, 297, 0, 4165, + 4164, 1, 0, 0, 0, 4165, 4166, 1, 0, 0, 0, 4166, 4168, 1, 0, 0, 0, 4167, + 4169, 3, 696, 348, 0, 4168, 4167, 1, 0, 0, 0, 4168, 4169, 1, 0, 0, 0, 4169, + 593, 1, 0, 0, 0, 4170, 4171, 5, 58, 0, 0, 4171, 4172, 5, 21, 0, 0, 4172, + 4173, 3, 952, 476, 0, 4173, 4174, 5, 22, 0, 0, 4174, 4175, 5, 265, 0, 0, + 4175, 595, 1, 0, 0, 0, 4176, 4177, 3, 598, 299, 0, 4177, 597, 1, 0, 0, + 0, 4178, 4179, 7, 14, 0, 0, 4179, 599, 1, 0, 0, 0, 4180, 4181, 5, 174, + 0, 0, 4181, 4182, 5, 102, 0, 0, 4182, 4183, 3, 952, 476, 0, 4183, 601, + 1, 0, 0, 0, 4184, 4185, 5, 320, 0, 0, 4185, 4189, 3, 1200, 600, 0, 4186, + 4187, 5, 321, 0, 0, 4187, 4189, 3, 1200, 600, 0, 4188, 4184, 1, 0, 0, 0, + 4188, 4186, 1, 0, 0, 0, 4189, 603, 1, 0, 0, 0, 4190, 4191, 3, 1200, 600, + 0, 4191, 4193, 3, 618, 309, 0, 4192, 4194, 3, 606, 303, 0, 4193, 4192, + 1, 0, 0, 0, 4193, 4194, 1, 0, 0, 0, 4194, 4196, 1, 0, 0, 0, 4195, 4197, + 3, 696, 348, 0, 4196, 4195, 1, 0, 0, 0, 4196, 4197, 1, 0, 0, 0, 4197, 605, + 1, 0, 0, 0, 4198, 4200, 3, 608, 304, 0, 4199, 4198, 1, 0, 0, 0, 4200, 4201, + 1, 0, 0, 0, 4201, 4199, 1, 0, 0, 0, 4201, 4202, 1, 0, 0, 0, 4202, 4204, + 1, 0, 0, 0, 4203, 4205, 3, 698, 349, 0, 4204, 4203, 1, 0, 0, 0, 4204, 4205, + 1, 0, 0, 0, 4205, 607, 1, 0, 0, 0, 4206, 4211, 3, 610, 305, 0, 4207, 4211, + 3, 612, 306, 0, 4208, 4211, 3, 614, 307, 0, 4209, 4211, 3, 666, 333, 0, + 4210, 4206, 1, 0, 0, 0, 4210, 4207, 1, 0, 0, 0, 4210, 4208, 1, 0, 0, 0, + 4210, 4209, 1, 0, 0, 0, 4211, 609, 1, 0, 0, 0, 4212, 4213, 5, 225, 0, 0, + 4213, 4214, 5, 195, 0, 0, 4214, 611, 1, 0, 0, 0, 4215, 4217, 3, 616, 308, + 0, 4216, 4215, 1, 0, 0, 0, 4216, 4217, 1, 0, 0, 0, 4217, 4218, 1, 0, 0, + 0, 4218, 4219, 3, 680, 340, 0, 4219, 613, 1, 0, 0, 0, 4220, 4221, 5, 182, + 0, 0, 4221, 615, 1, 0, 0, 0, 4222, 4223, 5, 148, 0, 0, 4223, 4224, 3, 1200, + 600, 0, 4224, 617, 1, 0, 0, 0, 4225, 4227, 3, 648, 324, 0, 4226, 4228, + 3, 1172, 586, 0, 4227, 4226, 1, 0, 0, 0, 4227, 4228, 1, 0, 0, 0, 4228, + 4230, 1, 0, 0, 0, 4229, 4231, 3, 620, 310, 0, 4230, 4229, 1, 0, 0, 0, 4230, + 4231, 1, 0, 0, 0, 4231, 4234, 1, 0, 0, 0, 4232, 4234, 3, 628, 314, 0, 4233, + 4225, 1, 0, 0, 0, 4233, 4232, 1, 0, 0, 0, 4234, 619, 1, 0, 0, 0, 4235, + 4237, 3, 628, 314, 0, 4236, 4238, 3, 624, 312, 0, 4237, 4236, 1, 0, 0, + 0, 4237, 4238, 1, 0, 0, 0, 4238, 4239, 1, 0, 0, 0, 4239, 4240, 6, 310, + -1, 0, 4240, 4248, 1, 0, 0, 0, 4241, 4243, 3, 626, 313, 0, 4242, 4244, + 3, 622, 311, 0, 4243, 4242, 1, 0, 0, 0, 4243, 4244, 1, 0, 0, 0, 4244, 4245, + 1, 0, 0, 0, 4245, 4246, 6, 310, -1, 0, 4246, 4248, 1, 0, 0, 0, 4247, 4235, + 1, 0, 0, 0, 4247, 4241, 1, 0, 0, 0, 4248, 621, 1, 0, 0, 0, 4249, 4250, + 3, 628, 314, 0, 4250, 623, 1, 0, 0, 0, 4251, 4252, 3, 626, 313, 0, 4252, + 625, 1, 0, 0, 0, 4253, 4254, 5, 324, 0, 0, 4254, 4255, 3, 952, 476, 0, + 4255, 627, 1, 0, 0, 0, 4256, 4257, 3, 646, 323, 0, 4257, 4258, 5, 21, 0, + 0, 4258, 4259, 3, 952, 476, 0, 4259, 4261, 5, 22, 0, 0, 4260, 4262, 3, + 644, 322, 0, 4261, 4260, 1, 0, 0, 0, 4261, 4262, 1, 0, 0, 0, 4262, 4267, + 1, 0, 0, 0, 4263, 4264, 3, 646, 323, 0, 4264, 4265, 3, 630, 315, 0, 4265, + 4267, 1, 0, 0, 0, 4266, 4256, 1, 0, 0, 0, 4266, 4263, 1, 0, 0, 0, 4267, + 629, 1, 0, 0, 0, 4268, 4269, 5, 183, 0, 0, 4269, 4271, 5, 21, 0, 0, 4270, + 4272, 3, 632, 316, 0, 4271, 4270, 1, 0, 0, 0, 4271, 4272, 1, 0, 0, 0, 4272, + 4274, 1, 0, 0, 0, 4273, 4275, 3, 634, 317, 0, 4274, 4273, 1, 0, 0, 0, 4274, + 4275, 1, 0, 0, 0, 4275, 4277, 1, 0, 0, 0, 4276, 4278, 3, 636, 318, 0, 4277, + 4276, 1, 0, 0, 0, 4277, 4278, 1, 0, 0, 0, 4278, 4280, 1, 0, 0, 0, 4279, + 4281, 3, 638, 319, 0, 4280, 4279, 1, 0, 0, 0, 4280, 4281, 1, 0, 0, 0, 4281, + 4283, 1, 0, 0, 0, 4282, 4284, 3, 640, 320, 0, 4283, 4282, 1, 0, 0, 0, 4283, + 4284, 1, 0, 0, 0, 4284, 4285, 1, 0, 0, 0, 4285, 4286, 5, 22, 0, 0, 4286, + 631, 1, 0, 0, 0, 4287, 4288, 5, 263, 0, 0, 4288, 4289, 5, 104, 0, 0, 4289, + 4290, 3, 642, 321, 0, 4290, 633, 1, 0, 0, 0, 4291, 4292, 5, 187, 0, 0, + 4292, 4293, 5, 60, 0, 0, 4293, 4294, 3, 642, 321, 0, 4294, 635, 1, 0, 0, + 0, 4295, 4296, 5, 209, 0, 0, 4296, 4297, 3, 642, 321, 0, 4297, 637, 1, + 0, 0, 0, 4298, 4299, 5, 214, 0, 0, 4299, 4300, 3, 642, 321, 0, 4300, 639, + 1, 0, 0, 0, 4301, 4305, 5, 151, 0, 0, 4302, 4303, 5, 337, 0, 0, 4303, 4305, + 5, 151, 0, 0, 4304, 4301, 1, 0, 0, 0, 4304, 4302, 1, 0, 0, 0, 4305, 641, + 1, 0, 0, 0, 4306, 4315, 3, 1236, 618, 0, 4307, 4315, 3, 1232, 616, 0, 4308, + 4315, 3, 1228, 614, 0, 4309, 4315, 3, 1224, 612, 0, 4310, 4311, 5, 11, + 0, 0, 4311, 4315, 3, 1236, 618, 0, 4312, 4313, 5, 11, 0, 0, 4313, 4315, + 3, 1224, 612, 0, 4314, 4306, 1, 0, 0, 0, 4314, 4307, 1, 0, 0, 0, 4314, + 4308, 1, 0, 0, 0, 4314, 4309, 1, 0, 0, 0, 4314, 4310, 1, 0, 0, 0, 4314, + 4312, 1, 0, 0, 0, 4315, 643, 1, 0, 0, 0, 4316, 4317, 5, 265, 0, 0, 4317, + 4320, 5, 286, 0, 0, 4318, 4320, 5, 265, 0, 0, 4319, 4316, 1, 0, 0, 0, 4319, + 4318, 1, 0, 0, 0, 4320, 645, 1, 0, 0, 0, 4321, 4322, 5, 179, 0, 0, 4322, + 4332, 5, 58, 0, 0, 4323, 4324, 5, 179, 0, 0, 4324, 4325, 5, 128, 0, 0, + 4325, 4332, 5, 58, 0, 0, 4326, 4327, 5, 179, 0, 0, 4327, 4328, 5, 60, 0, + 0, 4328, 4329, 5, 324, 0, 0, 4329, 4332, 5, 58, 0, 0, 4330, 4332, 5, 58, + 0, 0, 4331, 4321, 1, 0, 0, 0, 4331, 4323, 1, 0, 0, 0, 4331, 4326, 1, 0, + 0, 0, 4331, 4330, 1, 0, 0, 0, 4332, 647, 1, 0, 0, 0, 4333, 4335, 3, 650, + 325, 0, 4334, 4336, 3, 1182, 591, 0, 4335, 4334, 1, 0, 0, 0, 4335, 4336, + 1, 0, 0, 0, 4336, 649, 1, 0, 0, 0, 4337, 4342, 3, 658, 329, 0, 4338, 4342, + 3, 660, 330, 0, 4339, 4342, 3, 654, 327, 0, 4340, 4342, 3, 652, 326, 0, + 4341, 4337, 1, 0, 0, 0, 4341, 4338, 1, 0, 0, 0, 4341, 4339, 1, 0, 0, 0, + 4341, 4340, 1, 0, 0, 0, 4342, 651, 1, 0, 0, 0, 4343, 4344, 5, 119, 0, 0, + 4344, 4345, 3, 1216, 608, 0, 4345, 4346, 3, 662, 331, 0, 4346, 4347, 3, + 1218, 609, 0, 4347, 653, 1, 0, 0, 0, 4348, 4349, 5, 96, 0, 0, 4349, 4358, + 3, 1216, 608, 0, 4350, 4355, 3, 656, 328, 0, 4351, 4352, 5, 17, 0, 0, 4352, + 4354, 3, 656, 328, 0, 4353, 4351, 1, 0, 0, 0, 4354, 4357, 1, 0, 0, 0, 4355, + 4353, 1, 0, 0, 0, 4355, 4356, 1, 0, 0, 0, 4356, 4359, 1, 0, 0, 0, 4357, + 4355, 1, 0, 0, 0, 4358, 4350, 1, 0, 0, 0, 4358, 4359, 1, 0, 0, 0, 4359, + 4360, 1, 0, 0, 0, 4360, 4361, 3, 1218, 609, 0, 4361, 655, 1, 0, 0, 0, 4362, + 4364, 3, 648, 324, 0, 4363, 4365, 3, 1172, 586, 0, 4364, 4363, 1, 0, 0, + 0, 4364, 4365, 1, 0, 0, 0, 4365, 4367, 1, 0, 0, 0, 4366, 4368, 3, 664, + 332, 0, 4367, 4366, 1, 0, 0, 0, 4367, 4368, 1, 0, 0, 0, 4368, 4373, 1, + 0, 0, 0, 4369, 4370, 3, 1200, 600, 0, 4370, 4371, 3, 662, 331, 0, 4371, + 4373, 1, 0, 0, 0, 4372, 4362, 1, 0, 0, 0, 4372, 4369, 1, 0, 0, 0, 4373, + 657, 1, 0, 0, 0, 4374, 4377, 3, 1198, 599, 0, 4375, 4377, 5, 120, 0, 0, + 4376, 4374, 1, 0, 0, 0, 4376, 4375, 1, 0, 0, 0, 4377, 659, 1, 0, 0, 0, + 4378, 4379, 5, 56, 0, 0, 4379, 4380, 3, 1216, 608, 0, 4380, 4381, 3, 662, + 331, 0, 4381, 4382, 3, 1218, 609, 0, 4382, 661, 1, 0, 0, 0, 4383, 4385, + 3, 648, 324, 0, 4384, 4386, 3, 1172, 586, 0, 4385, 4384, 1, 0, 0, 0, 4385, + 4386, 1, 0, 0, 0, 4386, 4388, 1, 0, 0, 0, 4387, 4389, 3, 664, 332, 0, 4388, + 4387, 1, 0, 0, 0, 4388, 4389, 1, 0, 0, 0, 4389, 4391, 1, 0, 0, 0, 4390, + 4392, 3, 696, 348, 0, 4391, 4390, 1, 0, 0, 0, 4391, 4392, 1, 0, 0, 0, 4392, + 663, 1, 0, 0, 0, 4393, 4394, 3, 666, 333, 0, 4394, 665, 1, 0, 0, 0, 4395, + 4396, 5, 111, 0, 0, 4396, 4397, 5, 80, 0, 0, 4397, 667, 1, 0, 0, 0, 4398, + 4401, 3, 672, 336, 0, 4399, 4401, 3, 678, 339, 0, 4400, 4398, 1, 0, 0, + 0, 4400, 4399, 1, 0, 0, 0, 4401, 669, 1, 0, 0, 0, 4402, 4403, 5, 304, 0, + 0, 4403, 4404, 5, 111, 0, 0, 4404, 4405, 5, 332, 0, 0, 4405, 671, 1, 0, + 0, 0, 4406, 4407, 5, 225, 0, 0, 4407, 4408, 5, 195, 0, 0, 4408, 4410, 3, + 674, 337, 0, 4409, 4411, 3, 698, 349, 0, 4410, 4409, 1, 0, 0, 0, 4410, + 4411, 1, 0, 0, 0, 4411, 4413, 1, 0, 0, 0, 4412, 4414, 3, 696, 348, 0, 4413, + 4412, 1, 0, 0, 0, 4413, 4414, 1, 0, 0, 0, 4414, 673, 1, 0, 0, 0, 4415, + 4424, 5, 21, 0, 0, 4416, 4421, 3, 676, 338, 0, 4417, 4418, 5, 17, 0, 0, + 4418, 4420, 3, 676, 338, 0, 4419, 4417, 1, 0, 0, 0, 4420, 4423, 1, 0, 0, + 0, 4421, 4419, 1, 0, 0, 0, 4421, 4422, 1, 0, 0, 0, 4422, 4425, 1, 0, 0, + 0, 4423, 4421, 1, 0, 0, 0, 4424, 4416, 1, 0, 0, 0, 4424, 4425, 1, 0, 0, + 0, 4425, 4426, 1, 0, 0, 0, 4426, 4427, 5, 22, 0, 0, 4427, 675, 1, 0, 0, + 0, 4428, 4430, 3, 1200, 600, 0, 4429, 4431, 3, 1094, 547, 0, 4430, 4429, + 1, 0, 0, 0, 4430, 4431, 1, 0, 0, 0, 4431, 4433, 1, 0, 0, 0, 4432, 4434, + 3, 1096, 548, 0, 4433, 4432, 1, 0, 0, 0, 4433, 4434, 1, 0, 0, 0, 4434, + 677, 1, 0, 0, 0, 4435, 4436, 5, 138, 0, 0, 4436, 4437, 5, 21, 0, 0, 4437, + 4438, 3, 952, 476, 0, 4438, 4440, 5, 22, 0, 0, 4439, 4441, 3, 698, 349, + 0, 4440, 4439, 1, 0, 0, 0, 4440, 4441, 1, 0, 0, 0, 4441, 4443, 1, 0, 0, + 0, 4442, 4444, 3, 696, 348, 0, 4443, 4442, 1, 0, 0, 0, 4443, 4444, 1, 0, + 0, 0, 4444, 4456, 1, 0, 0, 0, 4445, 4446, 5, 176, 0, 0, 4446, 4447, 5, + 195, 0, 0, 4447, 4448, 3, 694, 347, 0, 4448, 4450, 3, 680, 340, 0, 4449, + 4451, 3, 698, 349, 0, 4450, 4449, 1, 0, 0, 0, 4450, 4451, 1, 0, 0, 0, 4451, + 4453, 1, 0, 0, 0, 4452, 4454, 3, 696, 348, 0, 4453, 4452, 1, 0, 0, 0, 4453, + 4454, 1, 0, 0, 0, 4454, 4456, 1, 0, 0, 0, 4455, 4435, 1, 0, 0, 0, 4455, + 4445, 1, 0, 0, 0, 4456, 679, 1, 0, 0, 0, 4457, 4458, 5, 234, 0, 0, 4458, + 4459, 3, 1198, 599, 0, 4459, 4461, 3, 694, 347, 0, 4460, 4462, 3, 690, + 345, 0, 4461, 4460, 1, 0, 0, 0, 4461, 4462, 1, 0, 0, 0, 4462, 4464, 1, + 0, 0, 0, 4463, 4465, 3, 682, 341, 0, 4464, 4463, 1, 0, 0, 0, 4464, 4465, + 1, 0, 0, 0, 4465, 681, 1, 0, 0, 0, 4466, 4468, 3, 684, 342, 0, 4467, 4469, + 3, 686, 343, 0, 4468, 4467, 1, 0, 0, 0, 4468, 4469, 1, 0, 0, 0, 4469, 4475, + 1, 0, 0, 0, 4470, 4472, 3, 686, 343, 0, 4471, 4473, 3, 684, 342, 0, 4472, + 4471, 1, 0, 0, 0, 4472, 4473, 1, 0, 0, 0, 4473, 4475, 1, 0, 0, 0, 4474, + 4466, 1, 0, 0, 0, 4474, 4470, 1, 0, 0, 0, 4475, 683, 1, 0, 0, 0, 4476, + 4477, 5, 84, 0, 0, 4477, 4478, 5, 281, 0, 0, 4478, 4479, 3, 688, 344, 0, + 4479, 685, 1, 0, 0, 0, 4480, 4481, 5, 84, 0, 0, 4481, 4482, 5, 156, 0, + 0, 4482, 4483, 3, 688, 344, 0, 4483, 687, 1, 0, 0, 0, 4484, 4485, 5, 337, + 0, 0, 4485, 4491, 5, 124, 0, 0, 4486, 4491, 5, 243, 0, 0, 4487, 4491, 5, + 137, 0, 0, 4488, 4489, 5, 257, 0, 0, 4489, 4491, 5, 80, 0, 0, 4490, 4484, + 1, 0, 0, 0, 4490, 4486, 1, 0, 0, 0, 4490, 4487, 1, 0, 0, 0, 4490, 4488, + 1, 0, 0, 0, 4491, 689, 1, 0, 0, 0, 4492, 4493, 5, 204, 0, 0, 4493, 4494, + 3, 692, 346, 0, 4494, 691, 1, 0, 0, 0, 4495, 4500, 5, 121, 0, 0, 4496, + 4500, 5, 72, 0, 0, 4497, 4498, 5, 111, 0, 0, 4498, 4500, 5, 66, 0, 0, 4499, + 4495, 1, 0, 0, 0, 4499, 4496, 1, 0, 0, 0, 4499, 4497, 1, 0, 0, 0, 4500, + 693, 1, 0, 0, 0, 4501, 4502, 5, 21, 0, 0, 4502, 4507, 3, 1200, 600, 0, + 4503, 4504, 5, 17, 0, 0, 4504, 4506, 3, 1200, 600, 0, 4505, 4503, 1, 0, + 0, 0, 4506, 4509, 1, 0, 0, 0, 4507, 4505, 1, 0, 0, 0, 4507, 4508, 1, 0, + 0, 0, 4508, 4510, 1, 0, 0, 0, 4509, 4507, 1, 0, 0, 0, 4510, 4511, 5, 22, + 0, 0, 4511, 695, 1, 0, 0, 0, 4512, 4513, 5, 85, 0, 0, 4513, 4514, 3, 1034, + 517, 0, 4514, 697, 1, 0, 0, 0, 4515, 4517, 5, 111, 0, 0, 4516, 4515, 1, + 0, 0, 0, 4516, 4517, 1, 0, 0, 0, 4517, 4518, 1, 0, 0, 0, 4518, 4519, 5, + 164, 0, 0, 4519, 699, 1, 0, 0, 0, 4520, 4523, 3, 1226, 613, 0, 4521, 4523, + 3, 1244, 622, 0, 4522, 4520, 1, 0, 0, 0, 4522, 4521, 1, 0, 0, 0, 4523, + 701, 1, 0, 0, 0, 4524, 4525, 5, 304, 0, 0, 4525, 4526, 5, 332, 0, 0, 4526, + 703, 1, 0, 0, 0, 4527, 4529, 5, 268, 0, 0, 4528, 4530, 5, 178, 0, 0, 4529, + 4528, 1, 0, 0, 0, 4529, 4530, 1, 0, 0, 0, 4530, 705, 1, 0, 0, 0, 4531, + 4532, 3, 708, 354, 0, 4532, 707, 1, 0, 0, 0, 4533, 4534, 3, 742, 371, 0, + 4534, 4536, 3, 718, 359, 0, 4535, 4537, 3, 754, 377, 0, 4536, 4535, 1, + 0, 0, 0, 4536, 4537, 1, 0, 0, 0, 4537, 4539, 1, 0, 0, 0, 4538, 4540, 3, + 1056, 528, 0, 4539, 4538, 1, 0, 0, 0, 4539, 4540, 1, 0, 0, 0, 4540, 4577, + 1, 0, 0, 0, 4541, 4542, 3, 714, 357, 0, 4542, 4543, 3, 716, 358, 0, 4543, + 4544, 6, 354, -1, 0, 4544, 4577, 1, 0, 0, 0, 4545, 4546, 3, 742, 371, 0, + 4546, 4547, 5, 40, 0, 0, 4547, 4548, 6, 354, -1, 0, 4548, 4577, 1, 0, 0, + 0, 4549, 4551, 3, 718, 359, 0, 4550, 4552, 3, 754, 377, 0, 4551, 4550, + 1, 0, 0, 0, 4551, 4552, 1, 0, 0, 0, 4552, 4554, 1, 0, 0, 0, 4553, 4555, + 3, 1056, 528, 0, 4554, 4553, 1, 0, 0, 0, 4554, 4555, 1, 0, 0, 0, 4555, + 4577, 1, 0, 0, 0, 4556, 4558, 3, 742, 371, 0, 4557, 4556, 1, 0, 0, 0, 4557, + 4558, 1, 0, 0, 0, 4558, 4559, 1, 0, 0, 0, 4559, 4560, 3, 788, 394, 0, 4560, + 4561, 6, 354, -1, 0, 4561, 4577, 1, 0, 0, 0, 4562, 4564, 3, 742, 371, 0, + 4563, 4562, 1, 0, 0, 0, 4563, 4564, 1, 0, 0, 0, 4564, 4565, 1, 0, 0, 0, + 4565, 4566, 3, 788, 394, 0, 4566, 4567, 3, 710, 355, 0, 4567, 4568, 6, + 354, -1, 0, 4568, 4577, 1, 0, 0, 0, 4569, 4571, 3, 742, 371, 0, 4570, 4569, + 1, 0, 0, 0, 4570, 4571, 1, 0, 0, 0, 4571, 4572, 1, 0, 0, 0, 4572, 4573, + 3, 788, 394, 0, 4573, 4574, 3, 712, 356, 0, 4574, 4575, 6, 354, -1, 0, + 4575, 4577, 1, 0, 0, 0, 4576, 4533, 1, 0, 0, 0, 4576, 4541, 1, 0, 0, 0, + 4576, 4545, 1, 0, 0, 0, 4576, 4549, 1, 0, 0, 0, 4576, 4557, 1, 0, 0, 0, + 4576, 4563, 1, 0, 0, 0, 4576, 4570, 1, 0, 0, 0, 4577, 709, 1, 0, 0, 0, + 4578, 4579, 7, 15, 0, 0, 4579, 711, 1, 0, 0, 0, 4580, 4581, 7, 16, 0, 0, + 4581, 713, 1, 0, 0, 0, 4582, 4583, 3, 742, 371, 0, 4583, 4584, 5, 17, 0, + 0, 4584, 715, 1, 0, 0, 0, 4585, 4586, 7, 17, 0, 0, 4586, 717, 1, 0, 0, + 0, 4587, 4590, 3, 726, 363, 0, 4588, 4590, 3, 720, 360, 0, 4589, 4587, + 1, 0, 0, 0, 4589, 4588, 1, 0, 0, 0, 4590, 719, 1, 0, 0, 0, 4591, 4592, + 3, 722, 361, 0, 4592, 721, 1, 0, 0, 0, 4593, 4594, 6, 361, -1, 0, 4594, + 4596, 3, 726, 363, 0, 4595, 4597, 3, 724, 362, 0, 4596, 4595, 1, 0, 0, + 0, 4597, 4598, 1, 0, 0, 0, 4598, 4596, 1, 0, 0, 0, 4598, 4599, 1, 0, 0, + 0, 4599, 4606, 1, 0, 0, 0, 4600, 4601, 3, 726, 363, 0, 4601, 4602, 3, 728, + 364, 0, 4602, 4603, 5, 71, 0, 0, 4603, 4604, 6, 361, -1, 0, 4604, 4606, + 1, 0, 0, 0, 4605, 4593, 1, 0, 0, 0, 4605, 4600, 1, 0, 0, 0, 4606, 4614, + 1, 0, 0, 0, 4607, 4608, 10, 1, 0, 0, 4608, 4609, 3, 728, 364, 0, 4609, + 4610, 5, 71, 0, 0, 4610, 4611, 6, 361, -1, 0, 4611, 4613, 1, 0, 0, 0, 4612, + 4607, 1, 0, 0, 0, 4613, 4616, 1, 0, 0, 0, 4614, 4612, 1, 0, 0, 0, 4614, + 4615, 1, 0, 0, 0, 4615, 723, 1, 0, 0, 0, 4616, 4614, 1, 0, 0, 0, 4617, + 4618, 3, 728, 364, 0, 4618, 4619, 3, 726, 363, 0, 4619, 725, 1, 0, 0, 0, + 4620, 4626, 3, 760, 380, 0, 4621, 4623, 3, 978, 489, 0, 4622, 4624, 3, + 1088, 544, 0, 4623, 4622, 1, 0, 0, 0, 4623, 4624, 1, 0, 0, 0, 4624, 4626, + 1, 0, 0, 0, 4625, 4620, 1, 0, 0, 0, 4625, 4621, 1, 0, 0, 0, 4626, 727, + 1, 0, 0, 0, 4627, 4629, 3, 738, 369, 0, 4628, 4627, 1, 0, 0, 0, 4628, 4629, + 1, 0, 0, 0, 4629, 4630, 1, 0, 0, 0, 4630, 4632, 3, 736, 368, 0, 4631, 4633, + 3, 1066, 533, 0, 4632, 4631, 1, 0, 0, 0, 4632, 4633, 1, 0, 0, 0, 4633, + 4634, 1, 0, 0, 0, 4634, 4636, 3, 734, 367, 0, 4635, 4637, 3, 732, 366, + 0, 4636, 4635, 1, 0, 0, 0, 4636, 4637, 1, 0, 0, 0, 4637, 4639, 1, 0, 0, + 0, 4638, 4640, 3, 730, 365, 0, 4639, 4638, 1, 0, 0, 0, 4639, 4640, 1, 0, + 0, 0, 4640, 729, 1, 0, 0, 0, 4641, 4645, 5, 150, 0, 0, 4642, 4643, 5, 150, + 0, 0, 4643, 4645, 5, 60, 0, 0, 4644, 4641, 1, 0, 0, 0, 4644, 4642, 1, 0, + 0, 0, 4645, 731, 1, 0, 0, 0, 4646, 4647, 5, 267, 0, 0, 4647, 733, 1, 0, + 0, 0, 4648, 4649, 7, 18, 0, 0, 4649, 735, 1, 0, 0, 0, 4650, 4651, 7, 19, + 0, 0, 4651, 737, 1, 0, 0, 0, 4652, 4654, 5, 72, 0, 0, 4653, 4655, 3, 740, + 370, 0, 4654, 4653, 1, 0, 0, 0, 4654, 4655, 1, 0, 0, 0, 4655, 4662, 1, + 0, 0, 0, 4656, 4662, 5, 87, 0, 0, 4657, 4659, 5, 77, 0, 0, 4658, 4660, + 3, 740, 370, 0, 4659, 4658, 1, 0, 0, 0, 4659, 4660, 1, 0, 0, 0, 4660, 4662, + 1, 0, 0, 0, 4661, 4652, 1, 0, 0, 0, 4661, 4656, 1, 0, 0, 0, 4661, 4657, + 1, 0, 0, 0, 4662, 739, 1, 0, 0, 0, 4663, 4664, 5, 87, 0, 0, 4664, 741, + 1, 0, 0, 0, 4665, 4667, 5, 104, 0, 0, 4666, 4668, 5, 92, 0, 0, 4667, 4666, + 1, 0, 0, 0, 4667, 4668, 1, 0, 0, 0, 4668, 4669, 1, 0, 0, 0, 4669, 4674, + 3, 744, 372, 0, 4670, 4671, 5, 17, 0, 0, 4671, 4673, 3, 744, 372, 0, 4672, + 4670, 1, 0, 0, 0, 4673, 4676, 1, 0, 0, 0, 4674, 4672, 1, 0, 0, 0, 4674, + 4675, 1, 0, 0, 0, 4675, 743, 1, 0, 0, 0, 4676, 4674, 1, 0, 0, 0, 4677, + 4678, 3, 1200, 600, 0, 4678, 4679, 5, 58, 0, 0, 4679, 4681, 3, 978, 489, + 0, 4680, 4682, 3, 746, 373, 0, 4681, 4680, 1, 0, 0, 0, 4681, 4682, 1, 0, + 0, 0, 4682, 745, 1, 0, 0, 0, 4683, 4684, 3, 748, 374, 0, 4684, 747, 1, + 0, 0, 0, 4685, 4686, 5, 104, 0, 0, 4686, 4688, 5, 158, 0, 0, 4687, 4689, + 3, 1088, 544, 0, 4688, 4687, 1, 0, 0, 0, 4688, 4689, 1, 0, 0, 0, 4689, + 4708, 1, 0, 0, 0, 4690, 4691, 5, 104, 0, 0, 4691, 4693, 5, 158, 0, 0, 4692, + 4694, 3, 1088, 544, 0, 4693, 4692, 1, 0, 0, 0, 4693, 4694, 1, 0, 0, 0, + 4694, 4695, 1, 0, 0, 0, 4695, 4696, 5, 317, 0, 0, 4696, 4697, 3, 750, 375, + 0, 4697, 4698, 5, 112, 0, 0, 4698, 4699, 3, 750, 375, 0, 4699, 4708, 1, + 0, 0, 0, 4700, 4701, 5, 104, 0, 0, 4701, 4703, 5, 158, 0, 0, 4702, 4704, + 3, 1088, 544, 0, 4703, 4702, 1, 0, 0, 0, 4703, 4704, 1, 0, 0, 0, 4704, + 4705, 1, 0, 0, 0, 4705, 4706, 5, 208, 0, 0, 4706, 4708, 3, 750, 375, 0, + 4707, 4685, 1, 0, 0, 0, 4707, 4690, 1, 0, 0, 0, 4707, 4700, 1, 0, 0, 0, + 4708, 749, 1, 0, 0, 0, 4709, 4712, 3, 752, 376, 0, 4710, 4712, 5, 318, + 0, 0, 4711, 4709, 1, 0, 0, 0, 4711, 4710, 1, 0, 0, 0, 4712, 751, 1, 0, + 0, 0, 4713, 4717, 3, 1236, 618, 0, 4714, 4717, 3, 1178, 589, 0, 4715, 4717, + 3, 1176, 588, 0, 4716, 4713, 1, 0, 0, 0, 4716, 4714, 1, 0, 0, 0, 4716, + 4715, 1, 0, 0, 0, 4717, 753, 1, 0, 0, 0, 4718, 4719, 3, 756, 378, 0, 4719, + 755, 1, 0, 0, 0, 4720, 4722, 5, 86, 0, 0, 4721, 4723, 3, 1066, 533, 0, + 4722, 4721, 1, 0, 0, 0, 4722, 4723, 1, 0, 0, 0, 4723, 4724, 1, 0, 0, 0, + 4724, 4725, 5, 60, 0, 0, 4725, 4730, 3, 758, 379, 0, 4726, 4727, 5, 17, + 0, 0, 4727, 4729, 3, 758, 379, 0, 4728, 4726, 1, 0, 0, 0, 4729, 4732, 1, + 0, 0, 0, 4730, 4728, 1, 0, 0, 0, 4730, 4731, 1, 0, 0, 0, 4731, 757, 1, + 0, 0, 0, 4732, 4730, 1, 0, 0, 0, 4733, 4735, 3, 952, 476, 0, 4734, 4736, + 3, 1172, 586, 0, 4735, 4734, 1, 0, 0, 0, 4735, 4736, 1, 0, 0, 0, 4736, + 4738, 1, 0, 0, 0, 4737, 4739, 3, 1094, 547, 0, 4738, 4737, 1, 0, 0, 0, + 4738, 4739, 1, 0, 0, 0, 4739, 4741, 1, 0, 0, 0, 4740, 4742, 3, 1096, 548, + 0, 4741, 4740, 1, 0, 0, 0, 4741, 4742, 1, 0, 0, 0, 4742, 759, 1, 0, 0, + 0, 4743, 4745, 3, 782, 391, 0, 4744, 4746, 3, 788, 394, 0, 4745, 4744, + 1, 0, 0, 0, 4745, 4746, 1, 0, 0, 0, 4746, 4748, 1, 0, 0, 0, 4747, 4749, + 3, 762, 381, 0, 4748, 4747, 1, 0, 0, 0, 4748, 4749, 1, 0, 0, 0, 4749, 761, + 1, 0, 0, 0, 4750, 4752, 3, 774, 387, 0, 4751, 4753, 3, 778, 389, 0, 4752, + 4751, 1, 0, 0, 0, 4752, 4753, 1, 0, 0, 0, 4753, 4755, 1, 0, 0, 0, 4754, + 4756, 3, 776, 388, 0, 4755, 4754, 1, 0, 0, 0, 4755, 4756, 1, 0, 0, 0, 4756, + 4758, 1, 0, 0, 0, 4757, 4759, 3, 898, 449, 0, 4758, 4757, 1, 0, 0, 0, 4758, + 4759, 1, 0, 0, 0, 4759, 4761, 1, 0, 0, 0, 4760, 4762, 3, 768, 384, 0, 4761, + 4760, 1, 0, 0, 0, 4761, 4762, 1, 0, 0, 0, 4762, 4765, 1, 0, 0, 0, 4763, + 4765, 3, 764, 382, 0, 4764, 4750, 1, 0, 0, 0, 4764, 4763, 1, 0, 0, 0, 4765, + 763, 1, 0, 0, 0, 4766, 4768, 3, 778, 389, 0, 4767, 4769, 3, 776, 388, 0, + 4768, 4767, 1, 0, 0, 0, 4768, 4769, 1, 0, 0, 0, 4769, 4771, 1, 0, 0, 0, + 4770, 4772, 3, 898, 449, 0, 4771, 4770, 1, 0, 0, 0, 4771, 4772, 1, 0, 0, + 0, 4772, 4774, 1, 0, 0, 0, 4773, 4775, 3, 768, 384, 0, 4774, 4773, 1, 0, + 0, 0, 4774, 4775, 1, 0, 0, 0, 4775, 4778, 1, 0, 0, 0, 4776, 4778, 3, 766, + 383, 0, 4777, 4766, 1, 0, 0, 0, 4777, 4776, 1, 0, 0, 0, 4778, 765, 1, 0, + 0, 0, 4779, 4781, 3, 776, 388, 0, 4780, 4782, 3, 898, 449, 0, 4781, 4780, + 1, 0, 0, 0, 4781, 4782, 1, 0, 0, 0, 4782, 4784, 1, 0, 0, 0, 4783, 4785, + 3, 768, 384, 0, 4784, 4783, 1, 0, 0, 0, 4784, 4785, 1, 0, 0, 0, 4785, 4792, + 1, 0, 0, 0, 4786, 4788, 3, 898, 449, 0, 4787, 4789, 3, 768, 384, 0, 4788, + 4787, 1, 0, 0, 0, 4788, 4789, 1, 0, 0, 0, 4789, 4792, 1, 0, 0, 0, 4790, + 4792, 3, 768, 384, 0, 4791, 4779, 1, 0, 0, 0, 4791, 4786, 1, 0, 0, 0, 4791, + 4790, 1, 0, 0, 0, 4792, 767, 1, 0, 0, 0, 4793, 4794, 3, 770, 385, 0, 4794, + 769, 1, 0, 0, 0, 4795, 4796, 5, 330, 0, 0, 4796, 4801, 3, 772, 386, 0, + 4797, 4798, 5, 17, 0, 0, 4798, 4800, 3, 772, 386, 0, 4799, 4797, 1, 0, + 0, 0, 4800, 4803, 1, 0, 0, 0, 4801, 4799, 1, 0, 0, 0, 4801, 4802, 1, 0, + 0, 0, 4802, 771, 1, 0, 0, 0, 4803, 4801, 1, 0, 0, 0, 4804, 4805, 3, 1200, + 600, 0, 4805, 4806, 5, 58, 0, 0, 4806, 4807, 3, 1012, 506, 0, 4807, 773, + 1, 0, 0, 0, 4808, 4809, 5, 329, 0, 0, 4809, 4810, 3, 952, 476, 0, 4810, + 775, 1, 0, 0, 0, 4811, 4812, 5, 306, 0, 0, 4812, 4813, 3, 952, 476, 0, + 4813, 777, 1, 0, 0, 0, 4814, 4817, 3, 780, 390, 0, 4815, 4817, 3, 1060, + 530, 0, 4816, 4814, 1, 0, 0, 0, 4816, 4815, 1, 0, 0, 0, 4817, 779, 1, 0, + 0, 0, 4818, 4819, 3, 1062, 531, 0, 4819, 4820, 5, 57, 0, 0, 4820, 781, + 1, 0, 0, 0, 4821, 4823, 5, 95, 0, 0, 4822, 4824, 3, 1066, 533, 0, 4823, + 4822, 1, 0, 0, 0, 4823, 4824, 1, 0, 0, 0, 4824, 4826, 1, 0, 0, 0, 4825, + 4827, 3, 786, 393, 0, 4826, 4825, 1, 0, 0, 0, 4826, 4827, 1, 0, 0, 0, 4827, + 4829, 1, 0, 0, 0, 4828, 4830, 3, 734, 367, 0, 4829, 4828, 1, 0, 0, 0, 4829, + 4830, 1, 0, 0, 0, 4830, 4832, 1, 0, 0, 0, 4831, 4833, 3, 784, 392, 0, 4832, + 4831, 1, 0, 0, 0, 4832, 4833, 1, 0, 0, 0, 4833, 4834, 1, 0, 0, 0, 4834, + 4851, 3, 934, 467, 0, 4835, 4837, 5, 95, 0, 0, 4836, 4838, 3, 1066, 533, + 0, 4837, 4836, 1, 0, 0, 0, 4837, 4838, 1, 0, 0, 0, 4838, 4840, 1, 0, 0, + 0, 4839, 4841, 3, 786, 393, 0, 4840, 4839, 1, 0, 0, 0, 4840, 4841, 1, 0, + 0, 0, 4841, 4843, 1, 0, 0, 0, 4842, 4844, 3, 734, 367, 0, 4843, 4842, 1, + 0, 0, 0, 4843, 4844, 1, 0, 0, 0, 4844, 4846, 1, 0, 0, 0, 4845, 4847, 3, + 784, 392, 0, 4846, 4845, 1, 0, 0, 0, 4846, 4847, 1, 0, 0, 0, 4847, 4848, + 1, 0, 0, 0, 4848, 4849, 5, 71, 0, 0, 4849, 4851, 6, 391, -1, 0, 4850, 4821, + 1, 0, 0, 0, 4850, 4835, 1, 0, 0, 0, 4851, 783, 1, 0, 0, 0, 4852, 4853, + 5, 58, 0, 0, 4853, 4857, 5, 96, 0, 0, 4854, 4855, 5, 58, 0, 0, 4855, 4857, + 3, 1198, 599, 0, 4856, 4852, 1, 0, 0, 0, 4856, 4854, 1, 0, 0, 0, 4857, + 785, 1, 0, 0, 0, 4858, 4859, 5, 104, 0, 0, 4859, 4866, 3, 1200, 600, 0, + 4860, 4861, 5, 104, 0, 0, 4861, 4862, 3, 1200, 600, 0, 4862, 4863, 5, 85, + 0, 0, 4863, 4864, 3, 1034, 517, 0, 4864, 4866, 1, 0, 0, 0, 4865, 4858, + 1, 0, 0, 0, 4865, 4860, 1, 0, 0, 0, 4866, 787, 1, 0, 0, 0, 4867, 4868, + 5, 71, 0, 0, 4868, 4869, 3, 790, 395, 0, 4869, 789, 1, 0, 0, 0, 4870, 4874, + 3, 794, 397, 0, 4871, 4873, 3, 792, 396, 0, 4872, 4871, 1, 0, 0, 0, 4873, + 4876, 1, 0, 0, 0, 4874, 4872, 1, 0, 0, 0, 4874, 4875, 1, 0, 0, 0, 4875, + 4884, 1, 0, 0, 0, 4876, 4874, 1, 0, 0, 0, 4877, 4878, 5, 34, 0, 0, 4878, + 4884, 6, 395, -1, 0, 4879, 4880, 5, 33, 0, 0, 4880, 4884, 6, 395, -1, 0, + 4881, 4882, 5, 35, 0, 0, 4882, 4884, 6, 395, -1, 0, 4883, 4870, 1, 0, 0, + 0, 4883, 4877, 1, 0, 0, 0, 4883, 4879, 1, 0, 0, 0, 4883, 4881, 1, 0, 0, + 0, 4884, 791, 1, 0, 0, 0, 4885, 4886, 5, 17, 0, 0, 4886, 4905, 3, 794, + 397, 0, 4887, 4889, 3, 930, 465, 0, 4888, 4887, 1, 0, 0, 0, 4888, 4889, + 1, 0, 0, 0, 4889, 4891, 1, 0, 0, 0, 4890, 4892, 3, 928, 464, 0, 4891, 4890, + 1, 0, 0, 0, 4891, 4892, 1, 0, 0, 0, 4892, 4894, 1, 0, 0, 0, 4893, 4895, + 3, 844, 422, 0, 4894, 4893, 1, 0, 0, 0, 4894, 4895, 1, 0, 0, 0, 4895, 4896, + 1, 0, 0, 0, 4896, 4898, 5, 62, 0, 0, 4897, 4899, 3, 1066, 533, 0, 4898, + 4897, 1, 0, 0, 0, 4898, 4899, 1, 0, 0, 0, 4899, 4900, 1, 0, 0, 0, 4900, + 4902, 3, 794, 397, 0, 4901, 4903, 3, 838, 419, 0, 4902, 4901, 1, 0, 0, + 0, 4902, 4903, 1, 0, 0, 0, 4903, 4905, 1, 0, 0, 0, 4904, 4885, 1, 0, 0, + 0, 4904, 4888, 1, 0, 0, 0, 4905, 793, 1, 0, 0, 0, 4906, 4907, 6, 397, -1, + 0, 4907, 4915, 3, 796, 398, 0, 4908, 4915, 3, 846, 423, 0, 4909, 4910, + 5, 21, 0, 0, 4910, 4911, 3, 834, 417, 0, 4911, 4912, 5, 22, 0, 0, 4912, + 4915, 1, 0, 0, 0, 4913, 4915, 3, 832, 416, 0, 4914, 4906, 1, 0, 0, 0, 4914, + 4908, 1, 0, 0, 0, 4914, 4909, 1, 0, 0, 0, 4914, 4913, 1, 0, 0, 0, 4915, + 4922, 1, 0, 0, 0, 4916, 4917, 10, 2, 0, 0, 4917, 4921, 3, 820, 410, 0, + 4918, 4919, 10, 1, 0, 0, 4919, 4921, 3, 802, 401, 0, 4920, 4916, 1, 0, + 0, 0, 4920, 4918, 1, 0, 0, 0, 4921, 4924, 1, 0, 0, 0, 4922, 4920, 1, 0, + 0, 0, 4922, 4923, 1, 0, 0, 0, 4923, 795, 1, 0, 0, 0, 4924, 4922, 1, 0, + 0, 0, 4925, 4926, 3, 926, 463, 0, 4926, 4928, 5, 22, 0, 0, 4927, 4929, + 3, 1066, 533, 0, 4928, 4927, 1, 0, 0, 0, 4928, 4929, 1, 0, 0, 0, 4929, + 4931, 1, 0, 0, 0, 4930, 4932, 3, 798, 399, 0, 4931, 4930, 1, 0, 0, 0, 4931, + 4932, 1, 0, 0, 0, 4932, 4942, 1, 0, 0, 0, 4933, 4934, 3, 880, 440, 0, 4934, + 4936, 5, 22, 0, 0, 4935, 4937, 3, 1066, 533, 0, 4936, 4935, 1, 0, 0, 0, + 4936, 4937, 1, 0, 0, 0, 4937, 4939, 1, 0, 0, 0, 4938, 4940, 3, 798, 399, + 0, 4939, 4938, 1, 0, 0, 0, 4939, 4940, 1, 0, 0, 0, 4940, 4942, 1, 0, 0, + 0, 4941, 4925, 1, 0, 0, 0, 4941, 4933, 1, 0, 0, 0, 4942, 797, 1, 0, 0, + 0, 4943, 4944, 5, 58, 0, 0, 4944, 4987, 3, 1200, 600, 0, 4945, 4987, 3, + 1200, 600, 0, 4946, 4947, 5, 58, 0, 0, 4947, 4948, 3, 1200, 600, 0, 4948, + 4950, 3, 916, 458, 0, 4949, 4951, 3, 800, 400, 0, 4950, 4949, 1, 0, 0, + 0, 4950, 4951, 1, 0, 0, 0, 4951, 4987, 1, 0, 0, 0, 4952, 4953, 5, 58, 0, + 0, 4953, 4954, 3, 1200, 600, 0, 4954, 4956, 3, 900, 450, 0, 4955, 4957, + 3, 800, 400, 0, 4956, 4955, 1, 0, 0, 0, 4956, 4957, 1, 0, 0, 0, 4957, 4987, + 1, 0, 0, 0, 4958, 4959, 5, 58, 0, 0, 4959, 4960, 3, 1200, 600, 0, 4960, + 4961, 3, 898, 449, 0, 4961, 4962, 6, 399, -1, 0, 4962, 4987, 1, 0, 0, 0, + 4963, 4964, 3, 1200, 600, 0, 4964, 4965, 3, 916, 458, 0, 4965, 4966, 3, + 800, 400, 0, 4966, 4987, 1, 0, 0, 0, 4967, 4968, 3, 1200, 600, 0, 4968, + 4969, 3, 900, 450, 0, 4969, 4970, 3, 800, 400, 0, 4970, 4987, 1, 0, 0, + 0, 4971, 4972, 3, 1200, 600, 0, 4972, 4973, 3, 898, 449, 0, 4973, 4974, + 6, 399, -1, 0, 4974, 4987, 1, 0, 0, 0, 4975, 4977, 3, 916, 458, 0, 4976, + 4978, 3, 800, 400, 0, 4977, 4976, 1, 0, 0, 0, 4977, 4978, 1, 0, 0, 0, 4978, + 4987, 1, 0, 0, 0, 4979, 4981, 3, 900, 450, 0, 4980, 4982, 3, 800, 400, + 0, 4981, 4980, 1, 0, 0, 0, 4981, 4982, 1, 0, 0, 0, 4982, 4987, 1, 0, 0, + 0, 4983, 4984, 3, 898, 449, 0, 4984, 4985, 6, 399, -1, 0, 4985, 4987, 1, + 0, 0, 0, 4986, 4943, 1, 0, 0, 0, 4986, 4945, 1, 0, 0, 0, 4986, 4946, 1, + 0, 0, 0, 4986, 4952, 1, 0, 0, 0, 4986, 4958, 1, 0, 0, 0, 4986, 4963, 1, + 0, 0, 0, 4986, 4967, 1, 0, 0, 0, 4986, 4971, 1, 0, 0, 0, 4986, 4975, 1, + 0, 0, 0, 4986, 4979, 1, 0, 0, 0, 4986, 4983, 1, 0, 0, 0, 4987, 799, 1, + 0, 0, 0, 4988, 4990, 5, 58, 0, 0, 4989, 4988, 1, 0, 0, 0, 4989, 4990, 1, + 0, 0, 0, 4990, 4991, 1, 0, 0, 0, 4991, 4992, 3, 1200, 600, 0, 4992, 801, + 1, 0, 0, 0, 4993, 4994, 5, 99, 0, 0, 4994, 4995, 3, 1200, 600, 0, 4995, + 4996, 5, 21, 0, 0, 4996, 4997, 3, 812, 406, 0, 4997, 4998, 5, 22, 0, 0, + 4998, 4999, 3, 804, 402, 0, 4999, 803, 1, 0, 0, 0, 5000, 5020, 3, 806, + 403, 0, 5001, 5002, 5, 104, 0, 0, 5002, 5004, 5, 287, 0, 0, 5003, 5005, + 3, 806, 403, 0, 5004, 5003, 1, 0, 0, 0, 5004, 5005, 1, 0, 0, 0, 5005, 5020, + 1, 0, 0, 0, 5006, 5007, 5, 104, 0, 0, 5007, 5008, 5, 287, 0, 0, 5008, 5010, + 3, 1200, 600, 0, 5009, 5011, 3, 806, 403, 0, 5010, 5009, 1, 0, 0, 0, 5010, + 5011, 1, 0, 0, 0, 5011, 5020, 1, 0, 0, 0, 5012, 5013, 5, 104, 0, 0, 5013, + 5014, 5, 287, 0, 0, 5014, 5015, 5, 58, 0, 0, 5015, 5017, 3, 1200, 600, + 0, 5016, 5018, 3, 806, 403, 0, 5017, 5016, 1, 0, 0, 0, 5017, 5018, 1, 0, + 0, 0, 5018, 5020, 1, 0, 0, 0, 5019, 5000, 1, 0, 0, 0, 5019, 5001, 1, 0, + 0, 0, 5019, 5006, 1, 0, 0, 0, 5019, 5012, 1, 0, 0, 0, 5020, 805, 1, 0, + 0, 0, 5021, 5022, 5, 239, 0, 0, 5022, 5023, 5, 21, 0, 0, 5023, 5024, 3, + 808, 404, 0, 5024, 5025, 5, 22, 0, 0, 5025, 807, 1, 0, 0, 0, 5026, 5029, + 3, 810, 405, 0, 5027, 5029, 3, 752, 376, 0, 5028, 5026, 1, 0, 0, 0, 5028, + 5027, 1, 0, 0, 0, 5029, 809, 1, 0, 0, 0, 5030, 5031, 5, 301, 0, 0, 5031, + 5032, 5, 21, 0, 0, 5032, 5033, 3, 752, 376, 0, 5033, 5034, 5, 58, 0, 0, + 5034, 5036, 3, 1170, 585, 0, 5035, 5037, 3, 1120, 560, 0, 5036, 5035, 1, + 0, 0, 0, 5036, 5037, 1, 0, 0, 0, 5037, 5038, 1, 0, 0, 0, 5038, 5039, 5, + 22, 0, 0, 5039, 811, 1, 0, 0, 0, 5040, 5041, 3, 814, 407, 0, 5041, 5043, + 3, 816, 408, 0, 5042, 5044, 3, 818, 409, 0, 5043, 5042, 1, 0, 0, 0, 5043, + 5044, 1, 0, 0, 0, 5044, 813, 1, 0, 0, 0, 5045, 5048, 3, 808, 404, 0, 5046, + 5048, 3, 1224, 612, 0, 5047, 5045, 1, 0, 0, 0, 5047, 5046, 1, 0, 0, 0, + 5048, 815, 1, 0, 0, 0, 5049, 5050, 7, 20, 0, 0, 5050, 817, 1, 0, 0, 0, + 5051, 5052, 5, 312, 0, 0, 5052, 5053, 5, 60, 0, 0, 5053, 5058, 3, 952, + 476, 0, 5054, 5055, 5, 17, 0, 0, 5055, 5057, 3, 952, 476, 0, 5056, 5054, + 1, 0, 0, 0, 5057, 5060, 1, 0, 0, 0, 5058, 5056, 1, 0, 0, 0, 5058, 5059, + 1, 0, 0, 0, 5059, 819, 1, 0, 0, 0, 5060, 5058, 1, 0, 0, 0, 5061, 5062, + 5, 326, 0, 0, 5062, 5064, 5, 21, 0, 0, 5063, 5065, 3, 1024, 512, 0, 5064, + 5063, 1, 0, 0, 0, 5064, 5065, 1, 0, 0, 0, 5065, 5066, 1, 0, 0, 0, 5066, + 5067, 3, 754, 377, 0, 5067, 5068, 5, 210, 0, 0, 5068, 5069, 3, 828, 414, + 0, 5069, 5070, 5, 222, 0, 0, 5070, 5071, 5, 21, 0, 0, 5071, 5072, 3, 822, + 411, 0, 5072, 5073, 5, 22, 0, 0, 5073, 5074, 5, 327, 0, 0, 5074, 5075, + 3, 1112, 556, 0, 5075, 5077, 5, 22, 0, 0, 5076, 5078, 3, 800, 400, 0, 5077, + 5076, 1, 0, 0, 0, 5077, 5078, 1, 0, 0, 0, 5078, 821, 1, 0, 0, 0, 5079, + 5080, 6, 411, -1, 0, 5080, 5081, 3, 824, 412, 0, 5081, 5087, 1, 0, 0, 0, + 5082, 5083, 10, 1, 0, 0, 5083, 5084, 5, 25, 0, 0, 5084, 5086, 3, 824, 412, + 0, 5085, 5082, 1, 0, 0, 0, 5086, 5089, 1, 0, 0, 0, 5087, 5085, 1, 0, 0, + 0, 5087, 5088, 1, 0, 0, 0, 5088, 823, 1, 0, 0, 0, 5089, 5087, 1, 0, 0, + 0, 5090, 5091, 6, 412, -1, 0, 5091, 5092, 3, 826, 413, 0, 5092, 5097, 1, + 0, 0, 0, 5093, 5094, 10, 1, 0, 0, 5094, 5096, 3, 826, 413, 0, 5095, 5093, + 1, 0, 0, 0, 5096, 5099, 1, 0, 0, 0, 5097, 5095, 1, 0, 0, 0, 5097, 5098, + 1, 0, 0, 0, 5098, 825, 1, 0, 0, 0, 5099, 5097, 1, 0, 0, 0, 5100, 5106, + 3, 1200, 600, 0, 5101, 5102, 5, 21, 0, 0, 5102, 5103, 3, 822, 411, 0, 5103, + 5104, 5, 22, 0, 0, 5104, 5106, 1, 0, 0, 0, 5105, 5100, 1, 0, 0, 0, 5105, + 5101, 1, 0, 0, 0, 5106, 827, 1, 0, 0, 0, 5107, 5112, 3, 830, 415, 0, 5108, + 5109, 5, 17, 0, 0, 5109, 5111, 3, 830, 415, 0, 5110, 5108, 1, 0, 0, 0, + 5111, 5114, 1, 0, 0, 0, 5112, 5110, 1, 0, 0, 0, 5112, 5113, 1, 0, 0, 0, + 5113, 829, 1, 0, 0, 0, 5114, 5112, 1, 0, 0, 0, 5115, 5116, 3, 952, 476, + 0, 5116, 5117, 5, 58, 0, 0, 5117, 5118, 3, 1200, 600, 0, 5118, 831, 1, + 0, 0, 0, 5119, 5121, 3, 978, 489, 0, 5120, 5122, 3, 852, 426, 0, 5121, + 5120, 1, 0, 0, 0, 5121, 5122, 1, 0, 0, 0, 5122, 833, 1, 0, 0, 0, 5123, + 5127, 3, 794, 397, 0, 5124, 5126, 3, 836, 418, 0, 5125, 5124, 1, 0, 0, + 0, 5126, 5129, 1, 0, 0, 0, 5127, 5125, 1, 0, 0, 0, 5127, 5128, 1, 0, 0, + 0, 5128, 835, 1, 0, 0, 0, 5129, 5127, 1, 0, 0, 0, 5130, 5132, 3, 930, 465, + 0, 5131, 5130, 1, 0, 0, 0, 5131, 5132, 1, 0, 0, 0, 5132, 5134, 1, 0, 0, + 0, 5133, 5135, 3, 928, 464, 0, 5134, 5133, 1, 0, 0, 0, 5134, 5135, 1, 0, + 0, 0, 5135, 5137, 1, 0, 0, 0, 5136, 5138, 3, 844, 422, 0, 5137, 5136, 1, + 0, 0, 0, 5137, 5138, 1, 0, 0, 0, 5138, 5139, 1, 0, 0, 0, 5139, 5141, 5, + 62, 0, 0, 5140, 5142, 3, 1066, 533, 0, 5141, 5140, 1, 0, 0, 0, 5141, 5142, + 1, 0, 0, 0, 5142, 5143, 1, 0, 0, 0, 5143, 5145, 3, 794, 397, 0, 5144, 5146, + 3, 838, 419, 0, 5145, 5144, 1, 0, 0, 0, 5145, 5146, 1, 0, 0, 0, 5146, 837, + 1, 0, 0, 0, 5147, 5149, 3, 840, 420, 0, 5148, 5147, 1, 0, 0, 0, 5149, 5150, + 1, 0, 0, 0, 5150, 5148, 1, 0, 0, 0, 5150, 5151, 1, 0, 0, 0, 5151, 839, + 1, 0, 0, 0, 5152, 5155, 3, 932, 466, 0, 5153, 5155, 3, 842, 421, 0, 5154, + 5152, 1, 0, 0, 0, 5154, 5153, 1, 0, 0, 0, 5155, 841, 1, 0, 0, 0, 5156, + 5157, 5, 102, 0, 0, 5157, 5158, 5, 21, 0, 0, 5158, 5163, 3, 1200, 600, + 0, 5159, 5160, 5, 18, 0, 0, 5160, 5162, 3, 1200, 600, 0, 5161, 5159, 1, + 0, 0, 0, 5162, 5165, 1, 0, 0, 0, 5163, 5161, 1, 0, 0, 0, 5163, 5164, 1, + 0, 0, 0, 5164, 5166, 1, 0, 0, 0, 5165, 5163, 1, 0, 0, 0, 5166, 5167, 5, + 22, 0, 0, 5167, 843, 1, 0, 0, 0, 5168, 5169, 7, 21, 0, 0, 5169, 845, 1, + 0, 0, 0, 5170, 5172, 3, 854, 427, 0, 5171, 5173, 3, 1066, 533, 0, 5172, + 5171, 1, 0, 0, 0, 5172, 5173, 1, 0, 0, 0, 5173, 5175, 1, 0, 0, 0, 5174, + 5176, 3, 852, 426, 0, 5175, 5174, 1, 0, 0, 0, 5175, 5176, 1, 0, 0, 0, 5176, + 5178, 1, 0, 0, 0, 5177, 5179, 3, 850, 425, 0, 5178, 5177, 1, 0, 0, 0, 5178, + 5179, 1, 0, 0, 0, 5179, 5181, 1, 0, 0, 0, 5180, 5182, 3, 848, 424, 0, 5181, + 5180, 1, 0, 0, 0, 5181, 5182, 1, 0, 0, 0, 5182, 847, 1, 0, 0, 0, 5183, + 5184, 5, 70, 0, 0, 5184, 5185, 5, 97, 0, 0, 5185, 5186, 5, 116, 0, 0, 5186, + 5187, 5, 58, 0, 0, 5187, 5188, 5, 82, 0, 0, 5188, 5195, 3, 952, 476, 0, + 5189, 5190, 5, 70, 0, 0, 5190, 5191, 5, 98, 0, 0, 5191, 5192, 5, 58, 0, + 0, 5192, 5193, 5, 82, 0, 0, 5193, 5195, 3, 952, 476, 0, 5194, 5183, 1, + 0, 0, 0, 5194, 5189, 1, 0, 0, 0, 5195, 849, 1, 0, 0, 0, 5196, 5197, 5, + 104, 0, 0, 5197, 5199, 5, 83, 0, 0, 5198, 5200, 3, 800, 400, 0, 5199, 5198, + 1, 0, 0, 0, 5199, 5200, 1, 0, 0, 0, 5200, 851, 1, 0, 0, 0, 5201, 5202, + 5, 58, 0, 0, 5202, 5247, 3, 1200, 600, 0, 5203, 5247, 3, 1200, 600, 0, + 5204, 5205, 5, 58, 0, 0, 5205, 5206, 3, 1200, 600, 0, 5206, 5208, 3, 916, + 458, 0, 5207, 5209, 3, 800, 400, 0, 5208, 5207, 1, 0, 0, 0, 5208, 5209, + 1, 0, 0, 0, 5209, 5247, 1, 0, 0, 0, 5210, 5211, 5, 58, 0, 0, 5211, 5212, + 3, 1200, 600, 0, 5212, 5214, 3, 900, 450, 0, 5213, 5215, 3, 800, 400, 0, + 5214, 5213, 1, 0, 0, 0, 5214, 5215, 1, 0, 0, 0, 5215, 5247, 1, 0, 0, 0, + 5216, 5217, 5, 58, 0, 0, 5217, 5218, 3, 1200, 600, 0, 5218, 5219, 3, 898, + 449, 0, 5219, 5220, 6, 426, -1, 0, 5220, 5247, 1, 0, 0, 0, 5221, 5222, + 3, 1200, 600, 0, 5222, 5224, 3, 916, 458, 0, 5223, 5225, 3, 800, 400, 0, + 5224, 5223, 1, 0, 0, 0, 5224, 5225, 1, 0, 0, 0, 5225, 5247, 1, 0, 0, 0, + 5226, 5227, 3, 1200, 600, 0, 5227, 5229, 3, 900, 450, 0, 5228, 5230, 3, + 800, 400, 0, 5229, 5228, 1, 0, 0, 0, 5229, 5230, 1, 0, 0, 0, 5230, 5247, + 1, 0, 0, 0, 5231, 5232, 3, 1200, 600, 0, 5232, 5233, 3, 898, 449, 0, 5233, + 5234, 6, 426, -1, 0, 5234, 5247, 1, 0, 0, 0, 5235, 5237, 3, 916, 458, 0, + 5236, 5238, 3, 800, 400, 0, 5237, 5236, 1, 0, 0, 0, 5237, 5238, 1, 0, 0, + 0, 5238, 5247, 1, 0, 0, 0, 5239, 5241, 3, 900, 450, 0, 5240, 5242, 3, 800, + 400, 0, 5241, 5240, 1, 0, 0, 0, 5241, 5242, 1, 0, 0, 0, 5242, 5247, 1, + 0, 0, 0, 5243, 5244, 3, 898, 449, 0, 5244, 5245, 6, 426, -1, 0, 5245, 5247, + 1, 0, 0, 0, 5246, 5201, 1, 0, 0, 0, 5246, 5203, 1, 0, 0, 0, 5246, 5204, + 1, 0, 0, 0, 5246, 5210, 1, 0, 0, 0, 5246, 5216, 1, 0, 0, 0, 5246, 5221, + 1, 0, 0, 0, 5246, 5226, 1, 0, 0, 0, 5246, 5231, 1, 0, 0, 0, 5246, 5235, + 1, 0, 0, 0, 5246, 5239, 1, 0, 0, 0, 5246, 5243, 1, 0, 0, 0, 5247, 853, + 1, 0, 0, 0, 5248, 5269, 3, 872, 436, 0, 5249, 5269, 3, 856, 428, 0, 5250, + 5251, 3, 1198, 599, 0, 5251, 5252, 5, 23, 0, 0, 5252, 5253, 6, 427, -1, + 0, 5253, 5269, 1, 0, 0, 0, 5254, 5255, 3, 1198, 599, 0, 5255, 5256, 5, + 18, 0, 0, 5256, 5257, 5, 21, 0, 0, 5257, 5258, 6, 427, -1, 0, 5258, 5269, + 1, 0, 0, 0, 5259, 5260, 3, 872, 436, 0, 5260, 5261, 5, 23, 0, 0, 5261, + 5262, 6, 427, -1, 0, 5262, 5269, 1, 0, 0, 0, 5263, 5264, 3, 872, 436, 0, + 5264, 5265, 5, 18, 0, 0, 5265, 5266, 5, 21, 0, 0, 5266, 5267, 6, 427, -1, + 0, 5267, 5269, 1, 0, 0, 0, 5268, 5248, 1, 0, 0, 0, 5268, 5249, 1, 0, 0, + 0, 5268, 5250, 1, 0, 0, 0, 5268, 5254, 1, 0, 0, 0, 5268, 5259, 1, 0, 0, + 0, 5268, 5263, 1, 0, 0, 0, 5269, 855, 1, 0, 0, 0, 5270, 5273, 3, 858, 429, + 0, 5271, 5273, 3, 870, 435, 0, 5272, 5270, 1, 0, 0, 0, 5272, 5271, 1, 0, + 0, 0, 5273, 857, 1, 0, 0, 0, 5274, 5277, 3, 1198, 599, 0, 5275, 5277, 3, + 860, 430, 0, 5276, 5274, 1, 0, 0, 0, 5276, 5275, 1, 0, 0, 0, 5277, 859, + 1, 0, 0, 0, 5278, 5279, 6, 430, -1, 0, 5279, 5280, 3, 862, 431, 0, 5280, + 5286, 1, 0, 0, 0, 5281, 5282, 10, 1, 0, 0, 5282, 5283, 5, 18, 0, 0, 5283, + 5285, 3, 1200, 600, 0, 5284, 5281, 1, 0, 0, 0, 5285, 5288, 1, 0, 0, 0, + 5286, 5284, 1, 0, 0, 0, 5286, 5287, 1, 0, 0, 0, 5287, 861, 1, 0, 0, 0, + 5288, 5286, 1, 0, 0, 0, 5289, 5290, 6, 431, -1, 0, 5290, 5291, 3, 1200, + 600, 0, 5291, 5292, 5, 11, 0, 0, 5292, 5293, 3, 1200, 600, 0, 5293, 5304, + 1, 0, 0, 0, 5294, 5295, 3, 1200, 600, 0, 5295, 5296, 5, 11, 0, 0, 5296, + 5297, 5, 55, 0, 0, 5297, 5304, 1, 0, 0, 0, 5298, 5299, 3, 1200, 600, 0, + 5299, 5300, 5, 11, 0, 0, 5300, 5301, 3, 1224, 612, 0, 5301, 5302, 3, 1200, + 600, 0, 5302, 5304, 1, 0, 0, 0, 5303, 5289, 1, 0, 0, 0, 5303, 5294, 1, + 0, 0, 0, 5303, 5298, 1, 0, 0, 0, 5304, 5318, 1, 0, 0, 0, 5305, 5306, 10, + 5, 0, 0, 5306, 5307, 5, 11, 0, 0, 5307, 5317, 3, 862, 431, 6, 5308, 5309, + 10, 3, 0, 0, 5309, 5310, 5, 11, 0, 0, 5310, 5317, 5, 55, 0, 0, 5311, 5312, + 10, 1, 0, 0, 5312, 5313, 5, 11, 0, 0, 5313, 5314, 3, 1224, 612, 0, 5314, + 5315, 3, 1200, 600, 0, 5315, 5317, 1, 0, 0, 0, 5316, 5305, 1, 0, 0, 0, + 5316, 5308, 1, 0, 0, 0, 5316, 5311, 1, 0, 0, 0, 5317, 5320, 1, 0, 0, 0, + 5318, 5316, 1, 0, 0, 0, 5318, 5319, 1, 0, 0, 0, 5319, 863, 1, 0, 0, 0, + 5320, 5318, 1, 0, 0, 0, 5321, 5322, 6, 432, -1, 0, 5322, 5323, 5, 325, + 0, 0, 5323, 5324, 3, 866, 433, 0, 5324, 5337, 1, 0, 0, 0, 5325, 5326, 10, + 2, 0, 0, 5326, 5327, 3, 868, 434, 0, 5327, 5328, 3, 866, 433, 0, 5328, + 5336, 1, 0, 0, 0, 5329, 5330, 10, 1, 0, 0, 5330, 5331, 3, 868, 434, 0, + 5331, 5332, 3, 1224, 612, 0, 5332, 5333, 3, 868, 434, 0, 5333, 5334, 3, + 866, 433, 0, 5334, 5336, 1, 0, 0, 0, 5335, 5325, 1, 0, 0, 0, 5335, 5329, + 1, 0, 0, 0, 5336, 5339, 1, 0, 0, 0, 5337, 5335, 1, 0, 0, 0, 5337, 5338, + 1, 0, 0, 0, 5338, 865, 1, 0, 0, 0, 5339, 5337, 1, 0, 0, 0, 5340, 5343, + 3, 1200, 600, 0, 5341, 5343, 5, 55, 0, 0, 5342, 5340, 1, 0, 0, 0, 5342, + 5341, 1, 0, 0, 0, 5343, 867, 1, 0, 0, 0, 5344, 5345, 5, 11, 0, 0, 5345, + 5346, 5, 325, 0, 0, 5346, 5347, 5, 26, 0, 0, 5347, 869, 1, 0, 0, 0, 5348, + 5355, 3, 864, 432, 0, 5349, 5350, 3, 864, 432, 0, 5350, 5351, 3, 868, 434, + 0, 5351, 5352, 3, 1224, 612, 0, 5352, 5353, 3, 1200, 600, 0, 5353, 5355, + 1, 0, 0, 0, 5354, 5348, 1, 0, 0, 0, 5354, 5349, 1, 0, 0, 0, 5355, 871, + 1, 0, 0, 0, 5356, 5358, 3, 874, 437, 0, 5357, 5359, 3, 876, 438, 0, 5358, + 5357, 1, 0, 0, 0, 5358, 5359, 1, 0, 0, 0, 5359, 5360, 1, 0, 0, 0, 5360, + 5361, 5, 22, 0, 0, 5361, 5367, 1, 0, 0, 0, 5362, 5363, 5, 101, 0, 0, 5363, + 5364, 5, 21, 0, 0, 5364, 5365, 5, 95, 0, 0, 5365, 5367, 6, 436, -1, 0, + 5366, 5356, 1, 0, 0, 0, 5366, 5362, 1, 0, 0, 0, 5367, 873, 1, 0, 0, 0, + 5368, 5369, 5, 101, 0, 0, 5369, 5370, 5, 21, 0, 0, 5370, 5375, 3, 878, + 439, 0, 5371, 5372, 5, 17, 0, 0, 5372, 5374, 3, 878, 439, 0, 5373, 5371, + 1, 0, 0, 0, 5374, 5377, 1, 0, 0, 0, 5375, 5373, 1, 0, 0, 0, 5375, 5376, + 1, 0, 0, 0, 5376, 875, 1, 0, 0, 0, 5377, 5375, 1, 0, 0, 0, 5378, 5379, + 5, 17, 0, 0, 5379, 5380, 3, 1050, 525, 0, 5380, 877, 1, 0, 0, 0, 5381, + 5383, 3, 952, 476, 0, 5382, 5384, 3, 1088, 544, 0, 5383, 5382, 1, 0, 0, + 0, 5383, 5384, 1, 0, 0, 0, 5384, 879, 1, 0, 0, 0, 5385, 5386, 3, 926, 463, + 0, 5386, 5391, 3, 882, 441, 0, 5387, 5388, 5, 17, 0, 0, 5388, 5390, 3, + 882, 441, 0, 5389, 5387, 1, 0, 0, 0, 5390, 5393, 1, 0, 0, 0, 5391, 5389, + 1, 0, 0, 0, 5391, 5392, 1, 0, 0, 0, 5392, 881, 1, 0, 0, 0, 5393, 5391, + 1, 0, 0, 0, 5394, 5425, 3, 952, 476, 0, 5395, 5425, 3, 888, 444, 0, 5396, + 5425, 3, 894, 447, 0, 5397, 5425, 3, 896, 448, 0, 5398, 5425, 3, 884, 442, + 0, 5399, 5425, 3, 1050, 525, 0, 5400, 5401, 5, 21, 0, 0, 5401, 5402, 3, + 894, 447, 0, 5402, 5403, 5, 22, 0, 0, 5403, 5404, 6, 441, -1, 0, 5404, + 5425, 1, 0, 0, 0, 5405, 5406, 5, 21, 0, 0, 5406, 5407, 3, 896, 448, 0, + 5407, 5408, 5, 22, 0, 0, 5408, 5409, 6, 441, -1, 0, 5409, 5425, 1, 0, 0, + 0, 5410, 5411, 5, 21, 0, 0, 5411, 5412, 3, 884, 442, 0, 5412, 5413, 5, + 22, 0, 0, 5413, 5414, 6, 441, -1, 0, 5414, 5425, 1, 0, 0, 0, 5415, 5416, + 5, 21, 0, 0, 5416, 5417, 3, 1050, 525, 0, 5417, 5418, 5, 22, 0, 0, 5418, + 5419, 6, 441, -1, 0, 5419, 5425, 1, 0, 0, 0, 5420, 5421, 5, 95, 0, 0, 5421, + 5425, 6, 441, -1, 0, 5422, 5423, 5, 104, 0, 0, 5423, 5425, 6, 441, -1, + 0, 5424, 5394, 1, 0, 0, 0, 5424, 5395, 1, 0, 0, 0, 5424, 5396, 1, 0, 0, + 0, 5424, 5397, 1, 0, 0, 0, 5424, 5398, 1, 0, 0, 0, 5424, 5399, 1, 0, 0, + 0, 5424, 5400, 1, 0, 0, 0, 5424, 5405, 1, 0, 0, 0, 5424, 5410, 1, 0, 0, + 0, 5424, 5415, 1, 0, 0, 0, 5424, 5420, 1, 0, 0, 0, 5424, 5422, 1, 0, 0, + 0, 5425, 883, 1, 0, 0, 0, 5426, 5427, 5, 146, 0, 0, 5427, 5428, 3, 886, + 443, 0, 5428, 885, 1, 0, 0, 0, 5429, 5432, 3, 1198, 599, 0, 5430, 5432, + 5, 324, 0, 0, 5431, 5429, 1, 0, 0, 0, 5431, 5430, 1, 0, 0, 0, 5432, 887, + 1, 0, 0, 0, 5433, 5434, 5, 291, 0, 0, 5434, 5435, 5, 21, 0, 0, 5435, 5436, + 3, 890, 445, 0, 5436, 5437, 5, 22, 0, 0, 5437, 889, 1, 0, 0, 0, 5438, 5443, + 3, 892, 446, 0, 5439, 5440, 5, 17, 0, 0, 5440, 5442, 3, 892, 446, 0, 5441, + 5439, 1, 0, 0, 0, 5442, 5445, 1, 0, 0, 0, 5443, 5441, 1, 0, 0, 0, 5443, + 5444, 1, 0, 0, 0, 5444, 891, 1, 0, 0, 0, 5445, 5443, 1, 0, 0, 0, 5446, + 5447, 3, 1200, 600, 0, 5447, 893, 1, 0, 0, 0, 5448, 5449, 5, 268, 0, 0, + 5449, 5453, 3, 796, 398, 0, 5450, 5451, 5, 268, 0, 0, 5451, 5453, 3, 1198, + 599, 0, 5452, 5448, 1, 0, 0, 0, 5452, 5450, 1, 0, 0, 0, 5453, 895, 1, 0, + 0, 0, 5454, 5455, 5, 215, 0, 0, 5455, 5456, 3, 1198, 599, 0, 5456, 897, + 1, 0, 0, 0, 5457, 5458, 5, 323, 0, 0, 5458, 5459, 3, 952, 476, 0, 5459, + 899, 1, 0, 0, 0, 5460, 5462, 5, 94, 0, 0, 5461, 5463, 3, 914, 457, 0, 5462, + 5461, 1, 0, 0, 0, 5462, 5463, 1, 0, 0, 0, 5463, 5464, 1, 0, 0, 0, 5464, + 5465, 5, 21, 0, 0, 5465, 5466, 3, 910, 455, 0, 5466, 5467, 5, 70, 0, 0, + 5467, 5468, 3, 1198, 599, 0, 5468, 5469, 5, 73, 0, 0, 5469, 5470, 3, 902, + 451, 0, 5470, 5471, 5, 22, 0, 0, 5471, 901, 1, 0, 0, 0, 5472, 5473, 3, + 904, 452, 0, 5473, 5474, 5, 22, 0, 0, 5474, 903, 1, 0, 0, 0, 5475, 5476, + 6, 452, -1, 0, 5476, 5477, 5, 21, 0, 0, 5477, 5478, 3, 906, 453, 0, 5478, + 5484, 1, 0, 0, 0, 5479, 5480, 10, 1, 0, 0, 5480, 5481, 5, 17, 0, 0, 5481, + 5483, 3, 906, 453, 0, 5482, 5479, 1, 0, 0, 0, 5483, 5486, 1, 0, 0, 0, 5484, + 5482, 1, 0, 0, 0, 5484, 5485, 1, 0, 0, 0, 5485, 905, 1, 0, 0, 0, 5486, + 5484, 1, 0, 0, 0, 5487, 5489, 3, 910, 455, 0, 5488, 5490, 3, 908, 454, + 0, 5489, 5488, 1, 0, 0, 0, 5489, 5490, 1, 0, 0, 0, 5490, 907, 1, 0, 0, + 0, 5491, 5493, 5, 58, 0, 0, 5492, 5491, 1, 0, 0, 0, 5492, 5493, 1, 0, 0, + 0, 5493, 5494, 1, 0, 0, 0, 5494, 5500, 3, 1244, 622, 0, 5495, 5497, 5, + 58, 0, 0, 5496, 5495, 1, 0, 0, 0, 5496, 5497, 1, 0, 0, 0, 5497, 5498, 1, + 0, 0, 0, 5498, 5500, 3, 1236, 618, 0, 5499, 5492, 1, 0, 0, 0, 5499, 5496, + 1, 0, 0, 0, 5500, 909, 1, 0, 0, 0, 5501, 5502, 5, 21, 0, 0, 5502, 5503, + 3, 912, 456, 0, 5503, 5504, 5, 22, 0, 0, 5504, 5507, 1, 0, 0, 0, 5505, + 5507, 3, 912, 456, 0, 5506, 5501, 1, 0, 0, 0, 5506, 5505, 1, 0, 0, 0, 5507, + 911, 1, 0, 0, 0, 5508, 5513, 3, 1198, 599, 0, 5509, 5510, 5, 17, 0, 0, + 5510, 5512, 3, 1198, 599, 0, 5511, 5509, 1, 0, 0, 0, 5512, 5515, 1, 0, + 0, 0, 5513, 5511, 1, 0, 0, 0, 5513, 5514, 1, 0, 0, 0, 5514, 913, 1, 0, + 0, 0, 5515, 5513, 1, 0, 0, 0, 5516, 5517, 5, 69, 0, 0, 5517, 5521, 5, 81, + 0, 0, 5518, 5519, 5, 74, 0, 0, 5519, 5521, 5, 81, 0, 0, 5520, 5516, 1, + 0, 0, 0, 5520, 5518, 1, 0, 0, 0, 5521, 915, 1, 0, 0, 0, 5522, 5523, 5, + 89, 0, 0, 5523, 5524, 5, 21, 0, 0, 5524, 5525, 3, 918, 459, 0, 5525, 5526, + 5, 70, 0, 0, 5526, 5527, 3, 954, 477, 0, 5527, 5528, 5, 73, 0, 0, 5528, + 5529, 5, 21, 0, 0, 5529, 5530, 3, 922, 461, 0, 5530, 5531, 5, 22, 0, 0, + 5531, 5532, 5, 22, 0, 0, 5532, 917, 1, 0, 0, 0, 5533, 5538, 3, 920, 460, + 0, 5534, 5535, 5, 17, 0, 0, 5535, 5537, 3, 920, 460, 0, 5536, 5534, 1, + 0, 0, 0, 5537, 5540, 1, 0, 0, 0, 5538, 5536, 1, 0, 0, 0, 5538, 5539, 1, + 0, 0, 0, 5539, 919, 1, 0, 0, 0, 5540, 5538, 1, 0, 0, 0, 5541, 5543, 3, + 952, 476, 0, 5542, 5544, 3, 800, 400, 0, 5543, 5542, 1, 0, 0, 0, 5543, + 5544, 1, 0, 0, 0, 5544, 921, 1, 0, 0, 0, 5545, 5550, 3, 924, 462, 0, 5546, + 5547, 5, 17, 0, 0, 5547, 5549, 3, 924, 462, 0, 5548, 5546, 1, 0, 0, 0, + 5549, 5552, 1, 0, 0, 0, 5550, 5548, 1, 0, 0, 0, 5550, 5551, 1, 0, 0, 0, + 5551, 923, 1, 0, 0, 0, 5552, 5550, 1, 0, 0, 0, 5553, 5555, 3, 952, 476, + 0, 5554, 5556, 3, 800, 400, 0, 5555, 5554, 1, 0, 0, 0, 5555, 5556, 1, 0, + 0, 0, 5556, 925, 1, 0, 0, 0, 5557, 5561, 3, 1198, 599, 0, 5558, 5559, 5, + 304, 0, 0, 5559, 5561, 5, 21, 0, 0, 5560, 5557, 1, 0, 0, 0, 5560, 5558, + 1, 0, 0, 0, 5561, 927, 1, 0, 0, 0, 5562, 5577, 5, 61, 0, 0, 5563, 5565, + 5, 72, 0, 0, 5564, 5566, 3, 740, 370, 0, 5565, 5564, 1, 0, 0, 0, 5565, + 5566, 1, 0, 0, 0, 5566, 5577, 1, 0, 0, 0, 5567, 5577, 5, 75, 0, 0, 5568, + 5570, 5, 77, 0, 0, 5569, 5571, 3, 740, 370, 0, 5570, 5569, 1, 0, 0, 0, + 5570, 5571, 1, 0, 0, 0, 5571, 5577, 1, 0, 0, 0, 5572, 5574, 5, 91, 0, 0, + 5573, 5575, 3, 740, 370, 0, 5574, 5573, 1, 0, 0, 0, 5574, 5575, 1, 0, 0, + 0, 5575, 5577, 1, 0, 0, 0, 5576, 5562, 1, 0, 0, 0, 5576, 5563, 1, 0, 0, + 0, 5576, 5567, 1, 0, 0, 0, 5576, 5568, 1, 0, 0, 0, 5576, 5572, 1, 0, 0, + 0, 5577, 929, 1, 0, 0, 0, 5578, 5579, 5, 322, 0, 0, 5579, 931, 1, 0, 0, + 0, 5580, 5581, 5, 84, 0, 0, 5581, 5582, 3, 952, 476, 0, 5582, 933, 1, 0, + 0, 0, 5583, 5588, 3, 936, 468, 0, 5584, 5585, 5, 17, 0, 0, 5585, 5587, + 3, 936, 468, 0, 5586, 5584, 1, 0, 0, 0, 5587, 5590, 1, 0, 0, 0, 5588, 5586, + 1, 0, 0, 0, 5588, 5589, 1, 0, 0, 0, 5589, 5592, 1, 0, 0, 0, 5590, 5588, + 1, 0, 0, 0, 5591, 5593, 5, 17, 0, 0, 5592, 5591, 1, 0, 0, 0, 5592, 5593, + 1, 0, 0, 0, 5593, 935, 1, 0, 0, 0, 5594, 5598, 3, 940, 470, 0, 5595, 5598, + 3, 942, 471, 0, 5596, 5598, 3, 938, 469, 0, 5597, 5594, 1, 0, 0, 0, 5597, + 5595, 1, 0, 0, 0, 5597, 5596, 1, 0, 0, 0, 5598, 937, 1, 0, 0, 0, 5599, + 5601, 5, 12, 0, 0, 5600, 5602, 3, 944, 472, 0, 5601, 5600, 1, 0, 0, 0, + 5601, 5602, 1, 0, 0, 0, 5602, 939, 1, 0, 0, 0, 5603, 5609, 3, 952, 476, + 0, 5604, 5609, 3, 830, 415, 0, 5605, 5606, 3, 952, 476, 0, 5606, 5607, + 3, 1200, 600, 0, 5607, 5609, 1, 0, 0, 0, 5608, 5603, 1, 0, 0, 0, 5608, + 5604, 1, 0, 0, 0, 5608, 5605, 1, 0, 0, 0, 5609, 941, 1, 0, 0, 0, 5610, + 5611, 3, 954, 477, 0, 5611, 5612, 5, 18, 0, 0, 5612, 5614, 5, 12, 0, 0, + 5613, 5615, 3, 944, 472, 0, 5614, 5613, 1, 0, 0, 0, 5614, 5615, 1, 0, 0, + 0, 5615, 943, 1, 0, 0, 0, 5616, 5622, 3, 946, 473, 0, 5617, 5619, 3, 946, + 473, 0, 5618, 5617, 1, 0, 0, 0, 5618, 5619, 1, 0, 0, 0, 5619, 5620, 1, + 0, 0, 0, 5620, 5622, 3, 948, 474, 0, 5621, 5616, 1, 0, 0, 0, 5621, 5618, + 1, 0, 0, 0, 5622, 945, 1, 0, 0, 0, 5623, 5624, 5, 68, 0, 0, 5624, 5625, + 5, 21, 0, 0, 5625, 5630, 3, 1200, 600, 0, 5626, 5627, 5, 17, 0, 0, 5627, + 5629, 3, 1200, 600, 0, 5628, 5626, 1, 0, 0, 0, 5629, 5632, 1, 0, 0, 0, + 5630, 5628, 1, 0, 0, 0, 5630, 5631, 1, 0, 0, 0, 5631, 5633, 1, 0, 0, 0, + 5632, 5630, 1, 0, 0, 0, 5633, 5634, 5, 22, 0, 0, 5634, 947, 1, 0, 0, 0, + 5635, 5636, 5, 93, 0, 0, 5636, 5637, 5, 21, 0, 0, 5637, 5642, 3, 950, 475, + 0, 5638, 5639, 5, 17, 0, 0, 5639, 5641, 3, 950, 475, 0, 5640, 5638, 1, + 0, 0, 0, 5641, 5644, 1, 0, 0, 0, 5642, 5640, 1, 0, 0, 0, 5642, 5643, 1, + 0, 0, 0, 5643, 5645, 1, 0, 0, 0, 5644, 5642, 1, 0, 0, 0, 5645, 5646, 5, + 22, 0, 0, 5646, 949, 1, 0, 0, 0, 5647, 5648, 3, 952, 476, 0, 5648, 5649, + 5, 58, 0, 0, 5649, 5650, 3, 1200, 600, 0, 5650, 951, 1, 0, 0, 0, 5651, + 5652, 6, 476, -1, 0, 5652, 5655, 3, 954, 477, 0, 5653, 5655, 3, 984, 492, + 0, 5654, 5651, 1, 0, 0, 0, 5654, 5653, 1, 0, 0, 0, 5655, 5661, 1, 0, 0, + 0, 5656, 5657, 10, 1, 0, 0, 5657, 5658, 5, 113, 0, 0, 5658, 5660, 3, 952, + 476, 2, 5659, 5656, 1, 0, 0, 0, 5660, 5663, 1, 0, 0, 0, 5661, 5659, 1, + 0, 0, 0, 5661, 5662, 1, 0, 0, 0, 5662, 953, 1, 0, 0, 0, 5663, 5661, 1, + 0, 0, 0, 5664, 5665, 6, 477, -1, 0, 5665, 5701, 3, 1240, 620, 0, 5666, + 5701, 3, 1242, 621, 0, 5667, 5701, 3, 1244, 622, 0, 5668, 5701, 3, 1238, + 619, 0, 5669, 5701, 3, 1236, 618, 0, 5670, 5701, 3, 1232, 616, 0, 5671, + 5701, 3, 1228, 614, 0, 5672, 5701, 3, 1226, 613, 0, 5673, 5701, 3, 1224, + 612, 0, 5674, 5701, 3, 1220, 610, 0, 5675, 5701, 3, 1166, 583, 0, 5676, + 5701, 3, 1178, 589, 0, 5677, 5701, 3, 1176, 588, 0, 5678, 5701, 3, 1160, + 580, 0, 5679, 5701, 3, 1152, 576, 0, 5680, 5701, 3, 1138, 569, 0, 5681, + 5701, 3, 1136, 568, 0, 5682, 5701, 3, 1134, 567, 0, 5683, 5701, 3, 1126, + 563, 0, 5684, 5701, 3, 1124, 562, 0, 5685, 5701, 3, 1116, 558, 0, 5686, + 5701, 3, 1110, 555, 0, 5687, 5701, 3, 1100, 550, 0, 5688, 5701, 3, 1006, + 503, 0, 5689, 5701, 3, 1004, 502, 0, 5690, 5701, 3, 1200, 600, 0, 5691, + 5701, 3, 994, 497, 0, 5692, 5701, 3, 992, 496, 0, 5693, 5694, 5, 111, 0, + 0, 5694, 5701, 3, 954, 477, 23, 5695, 5696, 3, 960, 480, 0, 5696, 5697, + 3, 954, 477, 3, 5697, 5701, 1, 0, 0, 0, 5698, 5701, 3, 980, 490, 0, 5699, + 5701, 3, 978, 489, 0, 5700, 5664, 1, 0, 0, 0, 5700, 5666, 1, 0, 0, 0, 5700, + 5667, 1, 0, 0, 0, 5700, 5668, 1, 0, 0, 0, 5700, 5669, 1, 0, 0, 0, 5700, + 5670, 1, 0, 0, 0, 5700, 5671, 1, 0, 0, 0, 5700, 5672, 1, 0, 0, 0, 5700, + 5673, 1, 0, 0, 0, 5700, 5674, 1, 0, 0, 0, 5700, 5675, 1, 0, 0, 0, 5700, + 5676, 1, 0, 0, 0, 5700, 5677, 1, 0, 0, 0, 5700, 5678, 1, 0, 0, 0, 5700, + 5679, 1, 0, 0, 0, 5700, 5680, 1, 0, 0, 0, 5700, 5681, 1, 0, 0, 0, 5700, + 5682, 1, 0, 0, 0, 5700, 5683, 1, 0, 0, 0, 5700, 5684, 1, 0, 0, 0, 5700, + 5685, 1, 0, 0, 0, 5700, 5686, 1, 0, 0, 0, 5700, 5687, 1, 0, 0, 0, 5700, + 5688, 1, 0, 0, 0, 5700, 5689, 1, 0, 0, 0, 5700, 5690, 1, 0, 0, 0, 5700, + 5691, 1, 0, 0, 0, 5700, 5692, 1, 0, 0, 0, 5700, 5693, 1, 0, 0, 0, 5700, + 5695, 1, 0, 0, 0, 5700, 5698, 1, 0, 0, 0, 5700, 5699, 1, 0, 0, 0, 5701, + 5809, 1, 0, 0, 0, 5702, 5703, 10, 20, 0, 0, 5703, 5704, 3, 990, 495, 0, + 5704, 5705, 3, 954, 477, 21, 5705, 5808, 1, 0, 0, 0, 5706, 5707, 10, 19, + 0, 0, 5707, 5708, 3, 976, 488, 0, 5708, 5709, 3, 954, 477, 20, 5709, 5808, + 1, 0, 0, 0, 5710, 5711, 10, 16, 0, 0, 5711, 5712, 3, 972, 486, 0, 5712, + 5713, 3, 954, 477, 0, 5713, 5714, 5, 112, 0, 0, 5714, 5715, 3, 954, 477, + 17, 5715, 5808, 1, 0, 0, 0, 5716, 5717, 10, 11, 0, 0, 5717, 5718, 3, 962, + 481, 0, 5718, 5719, 3, 954, 477, 12, 5719, 5808, 1, 0, 0, 0, 5720, 5721, + 10, 10, 0, 0, 5721, 5722, 5, 25, 0, 0, 5722, 5808, 3, 954, 477, 11, 5723, + 5724, 10, 9, 0, 0, 5724, 5725, 5, 41, 0, 0, 5725, 5808, 3, 954, 477, 10, + 5726, 5727, 10, 8, 0, 0, 5727, 5728, 5, 42, 0, 0, 5728, 5808, 3, 954, 477, + 9, 5729, 5730, 10, 7, 0, 0, 5730, 5731, 5, 43, 0, 0, 5731, 5808, 3, 954, + 477, 8, 5732, 5733, 10, 6, 0, 0, 5733, 5734, 3, 964, 482, 0, 5734, 5735, + 3, 954, 477, 7, 5735, 5808, 1, 0, 0, 0, 5736, 5737, 10, 5, 0, 0, 5737, + 5738, 3, 966, 483, 0, 5738, 5739, 3, 954, 477, 6, 5739, 5808, 1, 0, 0, + 0, 5740, 5741, 10, 4, 0, 0, 5741, 5742, 3, 968, 484, 0, 5742, 5743, 3, + 954, 477, 5, 5743, 5808, 1, 0, 0, 0, 5744, 5745, 10, 26, 0, 0, 5745, 5746, + 5, 23, 0, 0, 5746, 5747, 3, 952, 476, 0, 5747, 5748, 5, 24, 0, 0, 5748, + 5808, 1, 0, 0, 0, 5749, 5750, 10, 25, 0, 0, 5750, 5751, 5, 18, 0, 0, 5751, + 5752, 5, 21, 0, 0, 5752, 5753, 3, 1198, 599, 0, 5753, 5754, 5, 22, 0, 0, + 5754, 5808, 1, 0, 0, 0, 5755, 5756, 10, 24, 0, 0, 5756, 5757, 5, 18, 0, + 0, 5757, 5808, 3, 1200, 600, 0, 5758, 5759, 10, 22, 0, 0, 5759, 5760, 3, + 990, 495, 0, 5760, 5762, 3, 988, 494, 0, 5761, 5763, 3, 1066, 533, 0, 5762, + 5761, 1, 0, 0, 0, 5762, 5763, 1, 0, 0, 0, 5763, 5764, 1, 0, 0, 0, 5764, + 5765, 3, 872, 436, 0, 5765, 5808, 1, 0, 0, 0, 5766, 5767, 10, 21, 0, 0, + 5767, 5768, 3, 990, 495, 0, 5768, 5770, 3, 988, 494, 0, 5769, 5771, 3, + 1066, 533, 0, 5770, 5769, 1, 0, 0, 0, 5770, 5771, 1, 0, 0, 0, 5771, 5772, + 1, 0, 0, 0, 5772, 5773, 3, 982, 491, 0, 5773, 5808, 1, 0, 0, 0, 5774, 5775, + 10, 18, 0, 0, 5775, 5777, 3, 974, 487, 0, 5776, 5778, 3, 1066, 533, 0, + 5777, 5776, 1, 0, 0, 0, 5777, 5778, 1, 0, 0, 0, 5778, 5779, 1, 0, 0, 0, + 5779, 5780, 3, 872, 436, 0, 5780, 5781, 6, 477, -1, 0, 5781, 5808, 1, 0, + 0, 0, 5782, 5783, 10, 17, 0, 0, 5783, 5785, 3, 974, 487, 0, 5784, 5786, + 3, 1066, 533, 0, 5785, 5784, 1, 0, 0, 0, 5785, 5786, 1, 0, 0, 0, 5786, + 5787, 1, 0, 0, 0, 5787, 5788, 3, 958, 479, 0, 5788, 5808, 1, 0, 0, 0, 5789, + 5790, 10, 15, 0, 0, 5790, 5791, 3, 972, 486, 0, 5791, 5792, 3, 954, 477, + 0, 5792, 5793, 5, 113, 0, 0, 5793, 5794, 6, 477, -1, 0, 5794, 5808, 1, + 0, 0, 0, 5795, 5796, 10, 14, 0, 0, 5796, 5797, 3, 970, 485, 0, 5797, 5798, + 5, 279, 0, 0, 5798, 5808, 1, 0, 0, 0, 5799, 5800, 10, 13, 0, 0, 5800, 5801, + 3, 970, 485, 0, 5801, 5802, 3, 1240, 620, 0, 5802, 5808, 1, 0, 0, 0, 5803, + 5804, 10, 12, 0, 0, 5804, 5805, 3, 970, 485, 0, 5805, 5806, 3, 1242, 621, + 0, 5806, 5808, 1, 0, 0, 0, 5807, 5702, 1, 0, 0, 0, 5807, 5706, 1, 0, 0, + 0, 5807, 5710, 1, 0, 0, 0, 5807, 5716, 1, 0, 0, 0, 5807, 5720, 1, 0, 0, + 0, 5807, 5723, 1, 0, 0, 0, 5807, 5726, 1, 0, 0, 0, 5807, 5729, 1, 0, 0, + 0, 5807, 5732, 1, 0, 0, 0, 5807, 5736, 1, 0, 0, 0, 5807, 5740, 1, 0, 0, + 0, 5807, 5744, 1, 0, 0, 0, 5807, 5749, 1, 0, 0, 0, 5807, 5755, 1, 0, 0, + 0, 5807, 5758, 1, 0, 0, 0, 5807, 5766, 1, 0, 0, 0, 5807, 5774, 1, 0, 0, + 0, 5807, 5782, 1, 0, 0, 0, 5807, 5789, 1, 0, 0, 0, 5807, 5795, 1, 0, 0, + 0, 5807, 5799, 1, 0, 0, 0, 5807, 5803, 1, 0, 0, 0, 5808, 5811, 1, 0, 0, + 0, 5809, 5807, 1, 0, 0, 0, 5809, 5810, 1, 0, 0, 0, 5810, 955, 1, 0, 0, + 0, 5811, 5809, 1, 0, 0, 0, 5812, 5962, 3, 980, 490, 0, 5813, 5962, 3, 1240, + 620, 0, 5814, 5962, 3, 1242, 621, 0, 5815, 5962, 3, 1244, 622, 0, 5816, + 5962, 3, 1238, 619, 0, 5817, 5962, 3, 1236, 618, 0, 5818, 5962, 3, 1232, + 616, 0, 5819, 5962, 3, 1228, 614, 0, 5820, 5962, 3, 1226, 613, 0, 5821, + 5962, 3, 1224, 612, 0, 5822, 5962, 3, 1220, 610, 0, 5823, 5962, 3, 1166, + 583, 0, 5824, 5962, 3, 1178, 589, 0, 5825, 5962, 3, 1176, 588, 0, 5826, + 5962, 3, 1160, 580, 0, 5827, 5962, 3, 1152, 576, 0, 5828, 5962, 3, 1138, + 569, 0, 5829, 5962, 3, 1136, 568, 0, 5830, 5962, 3, 1134, 567, 0, 5831, + 5962, 3, 1126, 563, 0, 5832, 5962, 3, 1124, 562, 0, 5833, 5962, 3, 1116, + 558, 0, 5834, 5962, 3, 1110, 555, 0, 5835, 5962, 3, 1100, 550, 0, 5836, + 5962, 3, 1006, 503, 0, 5837, 5962, 3, 1004, 502, 0, 5838, 5962, 3, 1200, + 600, 0, 5839, 5962, 3, 994, 497, 0, 5840, 5962, 3, 992, 496, 0, 5841, 5842, + 3, 954, 477, 0, 5842, 5843, 5, 23, 0, 0, 5843, 5844, 3, 952, 476, 0, 5844, + 5845, 5, 24, 0, 0, 5845, 5962, 1, 0, 0, 0, 5846, 5847, 3, 954, 477, 0, + 5847, 5848, 5, 18, 0, 0, 5848, 5849, 5, 21, 0, 0, 5849, 5850, 3, 1198, + 599, 0, 5850, 5851, 5, 22, 0, 0, 5851, 5962, 1, 0, 0, 0, 5852, 5853, 3, + 954, 477, 0, 5853, 5854, 5, 18, 0, 0, 5854, 5855, 3, 1200, 600, 0, 5855, + 5962, 1, 0, 0, 0, 5856, 5857, 5, 111, 0, 0, 5857, 5962, 3, 954, 477, 0, + 5858, 5859, 3, 954, 477, 0, 5859, 5860, 3, 990, 495, 0, 5860, 5862, 3, + 988, 494, 0, 5861, 5863, 3, 1066, 533, 0, 5862, 5861, 1, 0, 0, 0, 5862, + 5863, 1, 0, 0, 0, 5863, 5864, 1, 0, 0, 0, 5864, 5865, 3, 872, 436, 0, 5865, + 5962, 1, 0, 0, 0, 5866, 5867, 3, 954, 477, 0, 5867, 5868, 3, 990, 495, + 0, 5868, 5870, 3, 988, 494, 0, 5869, 5871, 3, 1066, 533, 0, 5870, 5869, + 1, 0, 0, 0, 5870, 5871, 1, 0, 0, 0, 5871, 5872, 1, 0, 0, 0, 5872, 5873, + 3, 982, 491, 0, 5873, 5962, 1, 0, 0, 0, 5874, 5875, 3, 954, 477, 0, 5875, + 5876, 3, 990, 495, 0, 5876, 5877, 3, 954, 477, 0, 5877, 5962, 1, 0, 0, + 0, 5878, 5879, 3, 954, 477, 0, 5879, 5880, 3, 976, 488, 0, 5880, 5881, + 3, 954, 477, 0, 5881, 5962, 1, 0, 0, 0, 5882, 5883, 3, 954, 477, 0, 5883, + 5885, 3, 974, 487, 0, 5884, 5886, 3, 1066, 533, 0, 5885, 5884, 1, 0, 0, + 0, 5885, 5886, 1, 0, 0, 0, 5886, 5887, 1, 0, 0, 0, 5887, 5888, 3, 872, + 436, 0, 5888, 5889, 6, 478, -1, 0, 5889, 5962, 1, 0, 0, 0, 5890, 5891, + 3, 954, 477, 0, 5891, 5893, 3, 974, 487, 0, 5892, 5894, 3, 1066, 533, 0, + 5893, 5892, 1, 0, 0, 0, 5893, 5894, 1, 0, 0, 0, 5894, 5895, 1, 0, 0, 0, + 5895, 5896, 3, 958, 479, 0, 5896, 5962, 1, 0, 0, 0, 5897, 5898, 3, 954, + 477, 0, 5898, 5899, 3, 972, 486, 0, 5899, 5900, 3, 954, 477, 0, 5900, 5901, + 5, 112, 0, 0, 5901, 5902, 3, 954, 477, 0, 5902, 5962, 1, 0, 0, 0, 5903, + 5904, 3, 954, 477, 0, 5904, 5905, 3, 972, 486, 0, 5905, 5906, 3, 954, 477, + 0, 5906, 5907, 5, 113, 0, 0, 5907, 5908, 6, 478, -1, 0, 5908, 5962, 1, + 0, 0, 0, 5909, 5910, 3, 954, 477, 0, 5910, 5911, 3, 970, 485, 0, 5911, + 5912, 5, 279, 0, 0, 5912, 5962, 1, 0, 0, 0, 5913, 5914, 3, 954, 477, 0, + 5914, 5915, 3, 970, 485, 0, 5915, 5916, 3, 1240, 620, 0, 5916, 5962, 1, + 0, 0, 0, 5917, 5918, 3, 954, 477, 0, 5918, 5919, 3, 970, 485, 0, 5919, + 5920, 3, 1242, 621, 0, 5920, 5962, 1, 0, 0, 0, 5921, 5922, 3, 954, 477, + 0, 5922, 5923, 3, 962, 481, 0, 5923, 5924, 3, 954, 477, 0, 5924, 5962, + 1, 0, 0, 0, 5925, 5926, 3, 954, 477, 0, 5926, 5927, 5, 25, 0, 0, 5927, + 5928, 3, 954, 477, 0, 5928, 5962, 1, 0, 0, 0, 5929, 5930, 3, 954, 477, + 0, 5930, 5931, 5, 41, 0, 0, 5931, 5932, 3, 954, 477, 0, 5932, 5962, 1, + 0, 0, 0, 5933, 5934, 3, 954, 477, 0, 5934, 5935, 5, 42, 0, 0, 5935, 5936, + 3, 954, 477, 0, 5936, 5962, 1, 0, 0, 0, 5937, 5938, 3, 954, 477, 0, 5938, + 5939, 5, 43, 0, 0, 5939, 5940, 3, 954, 477, 0, 5940, 5962, 1, 0, 0, 0, + 5941, 5942, 3, 954, 477, 0, 5942, 5943, 3, 964, 482, 0, 5943, 5944, 3, + 954, 477, 0, 5944, 5962, 1, 0, 0, 0, 5945, 5946, 3, 954, 477, 0, 5946, + 5947, 3, 966, 483, 0, 5947, 5948, 3, 954, 477, 0, 5948, 5962, 1, 0, 0, + 0, 5949, 5950, 3, 954, 477, 0, 5950, 5951, 3, 968, 484, 0, 5951, 5952, + 3, 954, 477, 0, 5952, 5962, 1, 0, 0, 0, 5953, 5954, 3, 960, 480, 0, 5954, + 5955, 3, 954, 477, 0, 5955, 5962, 1, 0, 0, 0, 5956, 5962, 3, 984, 492, + 0, 5957, 5958, 3, 952, 476, 0, 5958, 5959, 5, 113, 0, 0, 5959, 5960, 3, + 952, 476, 0, 5960, 5962, 1, 0, 0, 0, 5961, 5812, 1, 0, 0, 0, 5961, 5813, + 1, 0, 0, 0, 5961, 5814, 1, 0, 0, 0, 5961, 5815, 1, 0, 0, 0, 5961, 5816, + 1, 0, 0, 0, 5961, 5817, 1, 0, 0, 0, 5961, 5818, 1, 0, 0, 0, 5961, 5819, + 1, 0, 0, 0, 5961, 5820, 1, 0, 0, 0, 5961, 5821, 1, 0, 0, 0, 5961, 5822, + 1, 0, 0, 0, 5961, 5823, 1, 0, 0, 0, 5961, 5824, 1, 0, 0, 0, 5961, 5825, + 1, 0, 0, 0, 5961, 5826, 1, 0, 0, 0, 5961, 5827, 1, 0, 0, 0, 5961, 5828, + 1, 0, 0, 0, 5961, 5829, 1, 0, 0, 0, 5961, 5830, 1, 0, 0, 0, 5961, 5831, + 1, 0, 0, 0, 5961, 5832, 1, 0, 0, 0, 5961, 5833, 1, 0, 0, 0, 5961, 5834, + 1, 0, 0, 0, 5961, 5835, 1, 0, 0, 0, 5961, 5836, 1, 0, 0, 0, 5961, 5837, + 1, 0, 0, 0, 5961, 5838, 1, 0, 0, 0, 5961, 5839, 1, 0, 0, 0, 5961, 5840, + 1, 0, 0, 0, 5961, 5841, 1, 0, 0, 0, 5961, 5846, 1, 0, 0, 0, 5961, 5852, + 1, 0, 0, 0, 5961, 5856, 1, 0, 0, 0, 5961, 5858, 1, 0, 0, 0, 5961, 5866, + 1, 0, 0, 0, 5961, 5874, 1, 0, 0, 0, 5961, 5878, 1, 0, 0, 0, 5961, 5882, + 1, 0, 0, 0, 5961, 5890, 1, 0, 0, 0, 5961, 5897, 1, 0, 0, 0, 5961, 5903, + 1, 0, 0, 0, 5961, 5909, 1, 0, 0, 0, 5961, 5913, 1, 0, 0, 0, 5961, 5917, + 1, 0, 0, 0, 5961, 5921, 1, 0, 0, 0, 5961, 5925, 1, 0, 0, 0, 5961, 5929, + 1, 0, 0, 0, 5961, 5933, 1, 0, 0, 0, 5961, 5937, 1, 0, 0, 0, 5961, 5941, + 1, 0, 0, 0, 5961, 5945, 1, 0, 0, 0, 5961, 5949, 1, 0, 0, 0, 5961, 5953, + 1, 0, 0, 0, 5961, 5956, 1, 0, 0, 0, 5961, 5957, 1, 0, 0, 0, 5962, 957, + 1, 0, 0, 0, 5963, 5972, 3, 978, 489, 0, 5964, 5965, 5, 21, 0, 0, 5965, + 5966, 3, 956, 478, 0, 5966, 5967, 5, 22, 0, 0, 5967, 5972, 1, 0, 0, 0, + 5968, 5969, 3, 986, 493, 0, 5969, 5970, 5, 22, 0, 0, 5970, 5972, 1, 0, + 0, 0, 5971, 5963, 1, 0, 0, 0, 5971, 5964, 1, 0, 0, 0, 5971, 5968, 1, 0, + 0, 0, 5972, 959, 1, 0, 0, 0, 5973, 5974, 7, 22, 0, 0, 5974, 961, 1, 0, + 0, 0, 5975, 5976, 7, 23, 0, 0, 5976, 963, 1, 0, 0, 0, 5977, 5978, 7, 24, + 0, 0, 5978, 965, 1, 0, 0, 0, 5979, 5980, 7, 25, 0, 0, 5980, 967, 1, 0, + 0, 0, 5981, 5982, 7, 26, 0, 0, 5982, 969, 1, 0, 0, 0, 5983, 5985, 5, 336, + 0, 0, 5984, 5986, 5, 111, 0, 0, 5985, 5984, 1, 0, 0, 0, 5985, 5986, 1, + 0, 0, 0, 5986, 971, 1, 0, 0, 0, 5987, 5989, 5, 111, 0, 0, 5988, 5987, 1, + 0, 0, 0, 5988, 5989, 1, 0, 0, 0, 5989, 5990, 1, 0, 0, 0, 5990, 5991, 5, + 317, 0, 0, 5991, 973, 1, 0, 0, 0, 5992, 5994, 5, 111, 0, 0, 5993, 5992, + 1, 0, 0, 0, 5993, 5994, 1, 0, 0, 0, 5994, 5995, 1, 0, 0, 0, 5995, 5996, + 5, 73, 0, 0, 5996, 975, 1, 0, 0, 0, 5997, 5999, 5, 336, 0, 0, 5998, 6000, + 5, 111, 0, 0, 5999, 5998, 1, 0, 0, 0, 5999, 6000, 1, 0, 0, 0, 6000, 6001, + 1, 0, 0, 0, 6001, 6002, 5, 66, 0, 0, 6002, 6003, 5, 71, 0, 0, 6003, 977, + 1, 0, 0, 0, 6004, 6005, 5, 21, 0, 0, 6005, 6006, 3, 706, 353, 0, 6006, + 6007, 5, 22, 0, 0, 6007, 979, 1, 0, 0, 0, 6008, 6009, 5, 21, 0, 0, 6009, + 6010, 3, 956, 478, 0, 6010, 6011, 5, 22, 0, 0, 6011, 981, 1, 0, 0, 0, 6012, + 6018, 3, 978, 489, 0, 6013, 6018, 3, 980, 490, 0, 6014, 6015, 3, 986, 493, + 0, 6015, 6016, 5, 22, 0, 0, 6016, 6018, 1, 0, 0, 0, 6017, 6012, 1, 0, 0, + 0, 6017, 6013, 1, 0, 0, 0, 6017, 6014, 1, 0, 0, 0, 6018, 983, 1, 0, 0, + 0, 6019, 6020, 3, 954, 477, 0, 6020, 6021, 5, 112, 0, 0, 6021, 6026, 3, + 954, 477, 0, 6022, 6023, 5, 112, 0, 0, 6023, 6025, 3, 954, 477, 0, 6024, + 6022, 1, 0, 0, 0, 6025, 6028, 1, 0, 0, 0, 6026, 6024, 1, 0, 0, 0, 6026, + 6027, 1, 0, 0, 0, 6027, 985, 1, 0, 0, 0, 6028, 6026, 1, 0, 0, 0, 6029, + 6030, 5, 21, 0, 0, 6030, 6031, 3, 952, 476, 0, 6031, 6032, 5, 17, 0, 0, + 6032, 6037, 3, 952, 476, 0, 6033, 6034, 5, 17, 0, 0, 6034, 6036, 3, 952, + 476, 0, 6035, 6033, 1, 0, 0, 0, 6036, 6039, 1, 0, 0, 0, 6037, 6035, 1, + 0, 0, 0, 6037, 6038, 1, 0, 0, 0, 6038, 987, 1, 0, 0, 0, 6039, 6037, 1, + 0, 0, 0, 6040, 6041, 7, 27, 0, 0, 6041, 989, 1, 0, 0, 0, 6042, 6046, 5, + 335, 0, 0, 6043, 6044, 5, 111, 0, 0, 6044, 6046, 5, 335, 0, 0, 6045, 6042, + 1, 0, 0, 0, 6045, 6043, 1, 0, 0, 0, 6046, 991, 1, 0, 0, 0, 6047, 6048, + 5, 56, 0, 0, 6048, 6055, 3, 978, 489, 0, 6049, 6051, 5, 332, 0, 0, 6050, + 6052, 3, 1066, 533, 0, 6051, 6050, 1, 0, 0, 0, 6051, 6052, 1, 0, 0, 0, + 6052, 6053, 1, 0, 0, 0, 6053, 6055, 3, 978, 489, 0, 6054, 6047, 1, 0, 0, + 0, 6054, 6049, 1, 0, 0, 0, 6055, 993, 1, 0, 0, 0, 6056, 6057, 3, 996, 498, + 0, 6057, 6058, 5, 22, 0, 0, 6058, 6066, 1, 0, 0, 0, 6059, 6060, 3, 1002, + 501, 0, 6060, 6061, 5, 22, 0, 0, 6061, 6066, 1, 0, 0, 0, 6062, 6063, 3, + 1000, 500, 0, 6063, 6064, 5, 22, 0, 0, 6064, 6066, 1, 0, 0, 0, 6065, 6056, + 1, 0, 0, 0, 6065, 6059, 1, 0, 0, 0, 6065, 6062, 1, 0, 0, 0, 6066, 995, + 1, 0, 0, 0, 6067, 6068, 3, 1002, 501, 0, 6068, 6073, 3, 998, 499, 0, 6069, + 6070, 5, 17, 0, 0, 6070, 6072, 3, 998, 499, 0, 6071, 6069, 1, 0, 0, 0, + 6072, 6075, 1, 0, 0, 0, 6073, 6071, 1, 0, 0, 0, 6073, 6074, 1, 0, 0, 0, + 6074, 997, 1, 0, 0, 0, 6075, 6073, 1, 0, 0, 0, 6076, 6078, 3, 952, 476, + 0, 6077, 6079, 3, 1088, 544, 0, 6078, 6077, 1, 0, 0, 0, 6078, 6079, 1, + 0, 0, 0, 6079, 999, 1, 0, 0, 0, 6080, 6081, 5, 21, 0, 0, 6081, 6082, 3, + 952, 476, 0, 6082, 6083, 5, 17, 0, 0, 6083, 6088, 3, 952, 476, 0, 6084, + 6085, 5, 17, 0, 0, 6085, 6087, 3, 952, 476, 0, 6086, 6084, 1, 0, 0, 0, + 6087, 6090, 1, 0, 0, 0, 6088, 6086, 1, 0, 0, 0, 6088, 6089, 1, 0, 0, 0, + 6089, 1001, 1, 0, 0, 0, 6090, 6088, 1, 0, 0, 0, 6091, 6092, 3, 1208, 604, + 0, 6092, 6093, 5, 21, 0, 0, 6093, 6097, 1, 0, 0, 0, 6094, 6095, 5, 96, + 0, 0, 6095, 6097, 5, 21, 0, 0, 6096, 6091, 1, 0, 0, 0, 6096, 6094, 1, 0, + 0, 0, 6097, 1003, 1, 0, 0, 0, 6098, 6099, 5, 120, 0, 0, 6099, 6100, 3, + 952, 476, 0, 6100, 6103, 3, 1200, 600, 0, 6101, 6102, 5, 331, 0, 0, 6102, + 6104, 3, 1200, 600, 0, 6103, 6101, 1, 0, 0, 0, 6103, 6104, 1, 0, 0, 0, + 6104, 1005, 1, 0, 0, 0, 6105, 6106, 3, 1198, 599, 0, 6106, 6108, 5, 21, + 0, 0, 6107, 6109, 5, 66, 0, 0, 6108, 6107, 1, 0, 0, 0, 6108, 6109, 1, 0, + 0, 0, 6109, 6110, 1, 0, 0, 0, 6110, 6111, 3, 1008, 504, 0, 6111, 6117, + 1, 0, 0, 0, 6112, 6113, 3, 1098, 549, 0, 6113, 6114, 5, 21, 0, 0, 6114, + 6115, 3, 1008, 504, 0, 6115, 6117, 1, 0, 0, 0, 6116, 6105, 1, 0, 0, 0, + 6116, 6112, 1, 0, 0, 0, 6117, 1007, 1, 0, 0, 0, 6118, 6120, 3, 1058, 529, + 0, 6119, 6118, 1, 0, 0, 0, 6119, 6120, 1, 0, 0, 0, 6120, 6122, 1, 0, 0, + 0, 6121, 6123, 3, 754, 377, 0, 6122, 6121, 1, 0, 0, 0, 6122, 6123, 1, 0, + 0, 0, 6123, 6125, 1, 0, 0, 0, 6124, 6126, 3, 1056, 528, 0, 6125, 6124, + 1, 0, 0, 0, 6125, 6126, 1, 0, 0, 0, 6126, 6127, 1, 0, 0, 0, 6127, 6159, + 5, 22, 0, 0, 6128, 6131, 3, 1046, 523, 0, 6129, 6131, 5, 12, 0, 0, 6130, + 6128, 1, 0, 0, 0, 6130, 6129, 1, 0, 0, 0, 6131, 6136, 1, 0, 0, 0, 6132, + 6133, 5, 17, 0, 0, 6133, 6135, 3, 1046, 523, 0, 6134, 6132, 1, 0, 0, 0, + 6135, 6138, 1, 0, 0, 0, 6136, 6134, 1, 0, 0, 0, 6136, 6137, 1, 0, 0, 0, + 6137, 6140, 1, 0, 0, 0, 6138, 6136, 1, 0, 0, 0, 6139, 6141, 3, 1044, 522, + 0, 6140, 6139, 1, 0, 0, 0, 6140, 6141, 1, 0, 0, 0, 6141, 6143, 1, 0, 0, + 0, 6142, 6144, 3, 1058, 529, 0, 6143, 6142, 1, 0, 0, 0, 6143, 6144, 1, + 0, 0, 0, 6144, 6146, 1, 0, 0, 0, 6145, 6147, 3, 1030, 515, 0, 6146, 6145, + 1, 0, 0, 0, 6146, 6147, 1, 0, 0, 0, 6147, 6149, 1, 0, 0, 0, 6148, 6150, + 3, 1028, 514, 0, 6149, 6148, 1, 0, 0, 0, 6149, 6150, 1, 0, 0, 0, 6150, + 6152, 1, 0, 0, 0, 6151, 6153, 3, 754, 377, 0, 6152, 6151, 1, 0, 0, 0, 6152, + 6153, 1, 0, 0, 0, 6153, 6155, 1, 0, 0, 0, 6154, 6156, 3, 1056, 528, 0, + 6155, 6154, 1, 0, 0, 0, 6155, 6156, 1, 0, 0, 0, 6156, 6157, 1, 0, 0, 0, + 6157, 6159, 5, 22, 0, 0, 6158, 6119, 1, 0, 0, 0, 6158, 6130, 1, 0, 0, 0, + 6159, 6161, 1, 0, 0, 0, 6160, 6162, 3, 1066, 533, 0, 6161, 6160, 1, 0, + 0, 0, 6161, 6162, 1, 0, 0, 0, 6162, 6164, 1, 0, 0, 0, 6163, 6165, 3, 1026, + 513, 0, 6164, 6163, 1, 0, 0, 0, 6164, 6165, 1, 0, 0, 0, 6165, 6167, 1, + 0, 0, 0, 6166, 6168, 3, 1010, 505, 0, 6167, 6166, 1, 0, 0, 0, 6167, 6168, + 1, 0, 0, 0, 6168, 1009, 1, 0, 0, 0, 6169, 6170, 5, 316, 0, 0, 6170, 6171, + 3, 1012, 506, 0, 6171, 1011, 1, 0, 0, 0, 6172, 6188, 3, 1200, 600, 0, 6173, + 6175, 5, 21, 0, 0, 6174, 6176, 3, 1200, 600, 0, 6175, 6174, 1, 0, 0, 0, + 6175, 6176, 1, 0, 0, 0, 6176, 6178, 1, 0, 0, 0, 6177, 6179, 3, 1022, 511, + 0, 6178, 6177, 1, 0, 0, 0, 6178, 6179, 1, 0, 0, 0, 6179, 6181, 1, 0, 0, + 0, 6180, 6182, 3, 754, 377, 0, 6181, 6180, 1, 0, 0, 0, 6181, 6182, 1, 0, + 0, 0, 6182, 6184, 1, 0, 0, 0, 6183, 6185, 3, 1014, 507, 0, 6184, 6183, + 1, 0, 0, 0, 6184, 6185, 1, 0, 0, 0, 6185, 6186, 1, 0, 0, 0, 6186, 6188, + 5, 22, 0, 0, 6187, 6172, 1, 0, 0, 0, 6187, 6173, 1, 0, 0, 0, 6188, 1013, + 1, 0, 0, 0, 6189, 6190, 3, 1020, 510, 0, 6190, 6191, 5, 317, 0, 0, 6191, + 6192, 3, 1016, 508, 0, 6192, 6193, 5, 112, 0, 0, 6193, 6194, 3, 1016, 508, + 0, 6194, 6199, 1, 0, 0, 0, 6195, 6196, 3, 1020, 510, 0, 6196, 6197, 3, + 1016, 508, 0, 6197, 6199, 1, 0, 0, 0, 6198, 6189, 1, 0, 0, 0, 6198, 6195, + 1, 0, 0, 0, 6199, 1015, 1, 0, 0, 0, 6200, 6201, 5, 318, 0, 0, 6201, 6208, + 3, 1018, 509, 0, 6202, 6203, 5, 319, 0, 0, 6203, 6208, 5, 249, 0, 0, 6204, + 6205, 3, 952, 476, 0, 6205, 6206, 3, 1018, 509, 0, 6206, 6208, 1, 0, 0, + 0, 6207, 6200, 1, 0, 0, 0, 6207, 6202, 1, 0, 0, 0, 6207, 6204, 1, 0, 0, + 0, 6208, 1017, 1, 0, 0, 0, 6209, 6210, 7, 28, 0, 0, 6210, 1019, 1, 0, 0, + 0, 6211, 6212, 7, 29, 0, 0, 6212, 1021, 1, 0, 0, 0, 6213, 6214, 3, 1024, + 512, 0, 6214, 1023, 1, 0, 0, 0, 6215, 6217, 5, 312, 0, 0, 6216, 6218, 3, + 1066, 533, 0, 6217, 6216, 1, 0, 0, 0, 6217, 6218, 1, 0, 0, 0, 6218, 6219, + 1, 0, 0, 0, 6219, 6220, 5, 60, 0, 0, 6220, 6225, 3, 952, 476, 0, 6221, + 6222, 5, 17, 0, 0, 6222, 6224, 3, 952, 476, 0, 6223, 6221, 1, 0, 0, 0, + 6224, 6227, 1, 0, 0, 0, 6225, 6223, 1, 0, 0, 0, 6225, 6226, 1, 0, 0, 0, + 6226, 1025, 1, 0, 0, 0, 6227, 6225, 1, 0, 0, 0, 6228, 6229, 5, 104, 0, + 0, 6229, 6230, 5, 307, 0, 0, 6230, 6231, 5, 315, 0, 0, 6231, 1027, 1, 0, + 0, 0, 6232, 6233, 5, 104, 0, 0, 6233, 6234, 5, 242, 0, 0, 6234, 6235, 3, + 1032, 516, 0, 6235, 1029, 1, 0, 0, 0, 6236, 6237, 5, 139, 0, 0, 6237, 6238, + 3, 954, 477, 0, 6238, 6239, 5, 112, 0, 0, 6239, 6240, 3, 952, 476, 0, 6240, + 1031, 1, 0, 0, 0, 6241, 6242, 3, 1034, 517, 0, 6242, 1033, 1, 0, 0, 0, + 6243, 6244, 3, 1036, 518, 0, 6244, 6245, 5, 22, 0, 0, 6245, 6249, 1, 0, + 0, 0, 6246, 6247, 5, 21, 0, 0, 6247, 6249, 5, 22, 0, 0, 6248, 6243, 1, + 0, 0, 0, 6248, 6246, 1, 0, 0, 0, 6249, 1035, 1, 0, 0, 0, 6250, 6251, 5, + 21, 0, 0, 6251, 6256, 3, 1038, 519, 0, 6252, 6253, 5, 17, 0, 0, 6253, 6255, + 3, 1038, 519, 0, 6254, 6252, 1, 0, 0, 0, 6255, 6258, 1, 0, 0, 0, 6256, + 6254, 1, 0, 0, 0, 6256, 6257, 1, 0, 0, 0, 6257, 1037, 1, 0, 0, 0, 6258, + 6256, 1, 0, 0, 0, 6259, 6260, 3, 1074, 537, 0, 6260, 6261, 3, 1042, 521, + 0, 6261, 6262, 3, 1040, 520, 0, 6262, 1039, 1, 0, 0, 0, 6263, 6266, 5, + 311, 0, 0, 6264, 6266, 3, 952, 476, 0, 6265, 6263, 1, 0, 0, 0, 6265, 6264, + 1, 0, 0, 0, 6266, 1041, 1, 0, 0, 0, 6267, 6268, 7, 30, 0, 0, 6268, 1043, + 1, 0, 0, 0, 6269, 6270, 5, 313, 0, 0, 6270, 6274, 5, 81, 0, 0, 6271, 6272, + 5, 314, 0, 0, 6272, 6274, 5, 81, 0, 0, 6273, 6269, 1, 0, 0, 0, 6273, 6271, + 1, 0, 0, 0, 6274, 1045, 1, 0, 0, 0, 6275, 6277, 3, 952, 476, 0, 6276, 6278, + 3, 1088, 544, 0, 6277, 6276, 1, 0, 0, 0, 6277, 6278, 1, 0, 0, 0, 6278, + 6285, 1, 0, 0, 0, 6279, 6285, 3, 1050, 525, 0, 6280, 6285, 3, 1052, 526, + 0, 6281, 6285, 3, 1048, 524, 0, 6282, 6283, 5, 95, 0, 0, 6283, 6285, 6, + 523, -1, 0, 6284, 6275, 1, 0, 0, 0, 6284, 6279, 1, 0, 0, 0, 6284, 6280, + 1, 0, 0, 0, 6284, 6281, 1, 0, 0, 0, 6284, 6282, 1, 0, 0, 0, 6285, 1047, + 1, 0, 0, 0, 6286, 6287, 5, 255, 0, 0, 6287, 6288, 3, 1198, 599, 0, 6288, + 1049, 1, 0, 0, 0, 6289, 6290, 3, 1200, 600, 0, 6290, 6291, 5, 36, 0, 0, + 6291, 6292, 3, 952, 476, 0, 6292, 6298, 1, 0, 0, 0, 6293, 6294, 3, 1200, + 600, 0, 6294, 6295, 5, 36, 0, 0, 6295, 6296, 3, 1052, 526, 0, 6296, 6298, + 1, 0, 0, 0, 6297, 6289, 1, 0, 0, 0, 6297, 6293, 1, 0, 0, 0, 6298, 1051, + 1, 0, 0, 0, 6299, 6300, 3, 1054, 527, 0, 6300, 6301, 5, 37, 0, 0, 6301, + 6302, 3, 952, 476, 0, 6302, 1053, 1, 0, 0, 0, 6303, 6307, 3, 952, 476, + 0, 6304, 6305, 5, 21, 0, 0, 6305, 6307, 5, 22, 0, 0, 6306, 6303, 1, 0, + 0, 0, 6306, 6304, 1, 0, 0, 0, 6307, 1055, 1, 0, 0, 0, 6308, 6309, 5, 78, + 0, 0, 6309, 6310, 3, 952, 476, 0, 6310, 6311, 5, 83, 0, 0, 6311, 6312, + 3, 952, 476, 0, 6312, 6316, 1, 0, 0, 0, 6313, 6314, 5, 78, 0, 0, 6314, + 6316, 3, 952, 476, 0, 6315, 6308, 1, 0, 0, 0, 6315, 6313, 1, 0, 0, 0, 6316, + 1057, 1, 0, 0, 0, 6317, 6318, 5, 306, 0, 0, 6318, 6319, 5, 208, 0, 0, 6319, + 6326, 3, 952, 476, 0, 6320, 6321, 5, 306, 0, 0, 6321, 6322, 5, 213, 0, + 0, 6322, 6323, 3, 952, 476, 0, 6323, 6324, 3, 1060, 530, 0, 6324, 6326, + 1, 0, 0, 0, 6325, 6317, 1, 0, 0, 0, 6325, 6320, 1, 0, 0, 0, 6326, 1059, + 1, 0, 0, 0, 6327, 6328, 3, 1062, 531, 0, 6328, 6333, 3, 1078, 539, 0, 6329, + 6330, 5, 17, 0, 0, 6330, 6332, 3, 1078, 539, 0, 6331, 6329, 1, 0, 0, 0, + 6332, 6335, 1, 0, 0, 0, 6333, 6331, 1, 0, 0, 0, 6333, 6334, 1, 0, 0, 0, + 6334, 1061, 1, 0, 0, 0, 6335, 6333, 1, 0, 0, 0, 6336, 6338, 5, 307, 0, + 0, 6337, 6339, 3, 1066, 533, 0, 6338, 6337, 1, 0, 0, 0, 6338, 6339, 1, + 0, 0, 0, 6339, 6341, 1, 0, 0, 0, 6340, 6342, 3, 1064, 532, 0, 6341, 6340, + 1, 0, 0, 0, 6341, 6342, 1, 0, 0, 0, 6342, 6343, 1, 0, 0, 0, 6343, 6344, + 5, 60, 0, 0, 6344, 1063, 1, 0, 0, 0, 6345, 6346, 5, 112, 0, 0, 6346, 6347, + 5, 86, 0, 0, 6347, 1065, 1, 0, 0, 0, 6348, 6349, 5, 34, 0, 0, 6349, 6352, + 3, 1236, 618, 0, 6350, 6352, 3, 1068, 534, 0, 6351, 6348, 1, 0, 0, 0, 6351, + 6350, 1, 0, 0, 0, 6352, 1067, 1, 0, 0, 0, 6353, 6354, 3, 1070, 535, 0, + 6354, 6355, 5, 20, 0, 0, 6355, 1069, 1, 0, 0, 0, 6356, 6360, 5, 34, 0, + 0, 6357, 6358, 3, 1236, 618, 0, 6358, 6359, 5, 34, 0, 0, 6359, 6361, 1, + 0, 0, 0, 6360, 6357, 1, 0, 0, 0, 6360, 6361, 1, 0, 0, 0, 6361, 6362, 1, + 0, 0, 0, 6362, 6363, 5, 19, 0, 0, 6363, 6368, 3, 1072, 536, 0, 6364, 6365, + 5, 17, 0, 0, 6365, 6367, 3, 1072, 536, 0, 6366, 6364, 1, 0, 0, 0, 6367, + 6370, 1, 0, 0, 0, 6368, 6366, 1, 0, 0, 0, 6368, 6369, 1, 0, 0, 0, 6369, + 1071, 1, 0, 0, 0, 6370, 6368, 1, 0, 0, 0, 6371, 6372, 3, 1074, 537, 0, + 6372, 6373, 5, 1, 0, 0, 6373, 6374, 3, 952, 476, 0, 6374, 6382, 1, 0, 0, + 0, 6375, 6376, 3, 1074, 537, 0, 6376, 6377, 5, 18, 0, 0, 6377, 6378, 3, + 1074, 537, 0, 6378, 6379, 5, 1, 0, 0, 6379, 6380, 3, 952, 476, 0, 6380, + 6382, 1, 0, 0, 0, 6381, 6371, 1, 0, 0, 0, 6381, 6375, 1, 0, 0, 0, 6382, + 1073, 1, 0, 0, 0, 6383, 6386, 3, 1200, 600, 0, 6384, 6386, 3, 1076, 538, + 0, 6385, 6383, 1, 0, 0, 0, 6385, 6384, 1, 0, 0, 0, 6386, 1075, 1, 0, 0, + 0, 6387, 6388, 7, 31, 0, 0, 6388, 1077, 1, 0, 0, 0, 6389, 6390, 5, 21, + 0, 0, 6390, 6408, 5, 22, 0, 0, 6391, 6393, 3, 952, 476, 0, 6392, 6394, + 3, 1088, 544, 0, 6393, 6392, 1, 0, 0, 0, 6393, 6394, 1, 0, 0, 0, 6394, + 6396, 1, 0, 0, 0, 6395, 6397, 3, 1090, 545, 0, 6396, 6395, 1, 0, 0, 0, + 6396, 6397, 1, 0, 0, 0, 6397, 6408, 1, 0, 0, 0, 6398, 6399, 3, 1086, 543, + 0, 6399, 6400, 5, 22, 0, 0, 6400, 6408, 1, 0, 0, 0, 6401, 6402, 3, 1084, + 542, 0, 6402, 6403, 5, 22, 0, 0, 6403, 6408, 1, 0, 0, 0, 6404, 6405, 3, + 1080, 540, 0, 6405, 6406, 5, 22, 0, 0, 6406, 6408, 1, 0, 0, 0, 6407, 6389, + 1, 0, 0, 0, 6407, 6391, 1, 0, 0, 0, 6407, 6398, 1, 0, 0, 0, 6407, 6401, + 1, 0, 0, 0, 6407, 6404, 1, 0, 0, 0, 6408, 1079, 1, 0, 0, 0, 6409, 6410, + 5, 305, 0, 0, 6410, 6411, 5, 256, 0, 0, 6411, 6412, 5, 21, 0, 0, 6412, + 6417, 3, 1082, 541, 0, 6413, 6414, 5, 17, 0, 0, 6414, 6416, 3, 1082, 541, + 0, 6415, 6413, 1, 0, 0, 0, 6416, 6419, 1, 0, 0, 0, 6417, 6415, 1, 0, 0, + 0, 6417, 6418, 1, 0, 0, 0, 6418, 1081, 1, 0, 0, 0, 6419, 6417, 1, 0, 0, + 0, 6420, 6421, 5, 21, 0, 0, 6421, 6430, 5, 22, 0, 0, 6422, 6430, 3, 952, + 476, 0, 6423, 6424, 3, 1086, 543, 0, 6424, 6425, 5, 22, 0, 0, 6425, 6430, + 1, 0, 0, 0, 6426, 6427, 3, 1084, 542, 0, 6427, 6428, 5, 22, 0, 0, 6428, + 6430, 1, 0, 0, 0, 6429, 6420, 1, 0, 0, 0, 6429, 6422, 1, 0, 0, 0, 6429, + 6423, 1, 0, 0, 0, 6429, 6426, 1, 0, 0, 0, 6430, 1083, 1, 0, 0, 0, 6431, + 6432, 5, 309, 0, 0, 6432, 6437, 5, 21, 0, 0, 6433, 6434, 5, 17, 0, 0, 6434, + 6436, 3, 952, 476, 0, 6435, 6433, 1, 0, 0, 0, 6436, 6439, 1, 0, 0, 0, 6437, + 6435, 1, 0, 0, 0, 6437, 6438, 1, 0, 0, 0, 6438, 1085, 1, 0, 0, 0, 6439, + 6437, 1, 0, 0, 0, 6440, 6441, 5, 308, 0, 0, 6441, 6442, 5, 21, 0, 0, 6442, + 6447, 3, 952, 476, 0, 6443, 6444, 5, 17, 0, 0, 6444, 6446, 3, 952, 476, + 0, 6445, 6443, 1, 0, 0, 0, 6446, 6449, 1, 0, 0, 0, 6447, 6445, 1, 0, 0, + 0, 6447, 6448, 1, 0, 0, 0, 6448, 1087, 1, 0, 0, 0, 6449, 6447, 1, 0, 0, + 0, 6450, 6451, 5, 58, 0, 0, 6451, 6452, 3, 1200, 600, 0, 6452, 1089, 1, + 0, 0, 0, 6453, 6456, 3, 1092, 546, 0, 6454, 6456, 3, 1096, 548, 0, 6455, + 6453, 1, 0, 0, 0, 6455, 6454, 1, 0, 0, 0, 6456, 1091, 1, 0, 0, 0, 6457, + 6459, 3, 1094, 547, 0, 6458, 6460, 3, 1096, 548, 0, 6459, 6458, 1, 0, 0, + 0, 6459, 6460, 1, 0, 0, 0, 6460, 1093, 1, 0, 0, 0, 6461, 6462, 7, 32, 0, + 0, 6462, 1095, 1, 0, 0, 0, 6463, 6464, 5, 81, 0, 0, 6464, 6468, 5, 175, + 0, 0, 6465, 6466, 5, 81, 0, 0, 6466, 6468, 5, 197, 0, 0, 6467, 6463, 1, + 0, 0, 0, 6467, 6465, 1, 0, 0, 0, 6468, 1097, 1, 0, 0, 0, 6469, 6470, 7, + 33, 0, 0, 6470, 1099, 1, 0, 0, 0, 6471, 6472, 3, 1102, 551, 0, 6472, 6473, + 5, 22, 0, 0, 6473, 1101, 1, 0, 0, 0, 6474, 6475, 5, 240, 0, 0, 6475, 6476, + 5, 21, 0, 0, 6476, 6477, 3, 952, 476, 0, 6477, 6478, 5, 17, 0, 0, 6478, + 6483, 3, 1104, 552, 0, 6479, 6480, 5, 17, 0, 0, 6480, 6482, 3, 1104, 552, + 0, 6481, 6479, 1, 0, 0, 0, 6482, 6485, 1, 0, 0, 0, 6483, 6481, 1, 0, 0, + 0, 6483, 6484, 1, 0, 0, 0, 6484, 1103, 1, 0, 0, 0, 6485, 6483, 1, 0, 0, + 0, 6486, 6487, 3, 952, 476, 0, 6487, 6488, 5, 58, 0, 0, 6488, 6489, 3, + 1106, 553, 0, 6489, 6495, 1, 0, 0, 0, 6490, 6491, 3, 952, 476, 0, 6491, + 6492, 5, 58, 0, 0, 6492, 6493, 3, 1108, 554, 0, 6493, 6495, 1, 0, 0, 0, + 6494, 6486, 1, 0, 0, 0, 6494, 6490, 1, 0, 0, 0, 6495, 1105, 1, 0, 0, 0, + 6496, 6497, 6, 553, -1, 0, 6497, 6498, 3, 1200, 600, 0, 6498, 6512, 1, + 0, 0, 0, 6499, 6500, 10, 3, 0, 0, 6500, 6501, 5, 18, 0, 0, 6501, 6511, + 3, 1108, 554, 0, 6502, 6503, 10, 2, 0, 0, 6503, 6504, 5, 18, 0, 0, 6504, + 6511, 3, 1200, 600, 0, 6505, 6506, 10, 1, 0, 0, 6506, 6507, 5, 23, 0, 0, + 6507, 6508, 3, 952, 476, 0, 6508, 6509, 5, 24, 0, 0, 6509, 6511, 1, 0, + 0, 0, 6510, 6499, 1, 0, 0, 0, 6510, 6502, 1, 0, 0, 0, 6510, 6505, 1, 0, + 0, 0, 6511, 6514, 1, 0, 0, 0, 6512, 6510, 1, 0, 0, 0, 6512, 6513, 1, 0, + 0, 0, 6513, 1107, 1, 0, 0, 0, 6514, 6512, 1, 0, 0, 0, 6515, 6516, 6, 554, + -1, 0, 6516, 6517, 5, 21, 0, 0, 6517, 6518, 3, 1198, 599, 0, 6518, 6519, + 5, 22, 0, 0, 6519, 6531, 1, 0, 0, 0, 6520, 6521, 10, 2, 0, 0, 6521, 6522, + 5, 18, 0, 0, 6522, 6523, 5, 21, 0, 0, 6523, 6524, 3, 1198, 599, 0, 6524, + 6525, 5, 22, 0, 0, 6525, 6530, 1, 0, 0, 0, 6526, 6527, 10, 1, 0, 0, 6527, + 6528, 5, 18, 0, 0, 6528, 6530, 3, 1200, 600, 0, 6529, 6520, 1, 0, 0, 0, + 6529, 6526, 1, 0, 0, 0, 6530, 6533, 1, 0, 0, 0, 6531, 6529, 1, 0, 0, 0, + 6531, 6532, 1, 0, 0, 0, 6532, 1109, 1, 0, 0, 0, 6533, 6531, 1, 0, 0, 0, + 6534, 6535, 5, 104, 0, 0, 6535, 6536, 5, 21, 0, 0, 6536, 6537, 3, 1112, + 556, 0, 6537, 6538, 5, 17, 0, 0, 6538, 6539, 3, 952, 476, 0, 6539, 6540, + 5, 22, 0, 0, 6540, 1111, 1, 0, 0, 0, 6541, 6546, 3, 1114, 557, 0, 6542, + 6543, 5, 17, 0, 0, 6543, 6545, 3, 1114, 557, 0, 6544, 6542, 1, 0, 0, 0, + 6545, 6548, 1, 0, 0, 0, 6546, 6544, 1, 0, 0, 0, 6546, 6547, 1, 0, 0, 0, + 6547, 1113, 1, 0, 0, 0, 6548, 6546, 1, 0, 0, 0, 6549, 6550, 3, 1200, 600, + 0, 6550, 6551, 5, 58, 0, 0, 6551, 6552, 3, 952, 476, 0, 6552, 1115, 1, + 0, 0, 0, 6553, 6554, 3, 1118, 559, 0, 6554, 6555, 5, 22, 0, 0, 6555, 6564, + 1, 0, 0, 0, 6556, 6557, 3, 1118, 559, 0, 6557, 6558, 5, 34, 0, 0, 6558, + 6559, 5, 116, 0, 0, 6559, 6560, 5, 290, 0, 0, 6560, 6561, 3, 952, 476, + 0, 6561, 6562, 5, 22, 0, 0, 6562, 6564, 1, 0, 0, 0, 6563, 6553, 1, 0, 0, + 0, 6563, 6556, 1, 0, 0, 0, 6564, 1117, 1, 0, 0, 0, 6565, 6566, 5, 302, + 0, 0, 6566, 6567, 5, 21, 0, 0, 6567, 6568, 3, 952, 476, 0, 6568, 6569, + 5, 71, 0, 0, 6569, 6570, 3, 952, 476, 0, 6570, 1119, 1, 0, 0, 0, 6571, + 6572, 5, 177, 0, 0, 6572, 6574, 3, 952, 476, 0, 6573, 6575, 3, 1122, 561, + 0, 6574, 6573, 1, 0, 0, 0, 6574, 6575, 1, 0, 0, 0, 6575, 1121, 1, 0, 0, + 0, 6576, 6577, 5, 34, 0, 0, 6577, 6578, 5, 116, 0, 0, 6578, 6579, 5, 290, + 0, 0, 6579, 6580, 3, 952, 476, 0, 6580, 1123, 1, 0, 0, 0, 6581, 6582, 5, + 301, 0, 0, 6582, 6583, 5, 21, 0, 0, 6583, 6584, 3, 952, 476, 0, 6584, 6585, + 5, 58, 0, 0, 6585, 6587, 3, 1170, 585, 0, 6586, 6588, 3, 1120, 560, 0, + 6587, 6586, 1, 0, 0, 0, 6587, 6588, 1, 0, 0, 0, 6588, 6589, 1, 0, 0, 0, + 6589, 6590, 5, 22, 0, 0, 6590, 6610, 1, 0, 0, 0, 6591, 6592, 5, 301, 0, + 0, 6592, 6593, 5, 21, 0, 0, 6593, 6594, 5, 301, 0, 0, 6594, 6610, 6, 562, + -1, 0, 6595, 6596, 5, 251, 0, 0, 6596, 6597, 5, 21, 0, 0, 6597, 6598, 3, + 952, 476, 0, 6598, 6599, 5, 58, 0, 0, 6599, 6601, 3, 1170, 585, 0, 6600, + 6602, 3, 1120, 560, 0, 6601, 6600, 1, 0, 0, 0, 6601, 6602, 1, 0, 0, 0, + 6602, 6603, 1, 0, 0, 0, 6603, 6604, 5, 22, 0, 0, 6604, 6610, 1, 0, 0, 0, + 6605, 6606, 5, 251, 0, 0, 6606, 6607, 5, 21, 0, 0, 6607, 6608, 5, 251, + 0, 0, 6608, 6610, 6, 562, -1, 0, 6609, 6581, 1, 0, 0, 0, 6609, 6591, 1, + 0, 0, 0, 6609, 6595, 1, 0, 0, 0, 6609, 6605, 1, 0, 0, 0, 6610, 1125, 1, + 0, 0, 0, 6611, 6612, 3, 1128, 564, 0, 6612, 6613, 5, 296, 0, 0, 6613, 6620, + 1, 0, 0, 0, 6614, 6615, 3, 1128, 564, 0, 6615, 6616, 5, 300, 0, 0, 6616, + 6617, 3, 952, 476, 0, 6617, 6618, 5, 296, 0, 0, 6618, 6620, 1, 0, 0, 0, + 6619, 6611, 1, 0, 0, 0, 6619, 6614, 1, 0, 0, 0, 6620, 1127, 1, 0, 0, 0, + 6621, 6624, 3, 1132, 566, 0, 6622, 6624, 3, 1130, 565, 0, 6623, 6621, 1, + 0, 0, 0, 6623, 6622, 1, 0, 0, 0, 6624, 1129, 1, 0, 0, 0, 6625, 6626, 5, + 297, 0, 0, 6626, 6632, 3, 952, 476, 0, 6627, 6628, 5, 298, 0, 0, 6628, + 6629, 3, 952, 476, 0, 6629, 6630, 5, 299, 0, 0, 6630, 6631, 3, 952, 476, + 0, 6631, 6633, 1, 0, 0, 0, 6632, 6627, 1, 0, 0, 0, 6633, 6634, 1, 0, 0, + 0, 6634, 6632, 1, 0, 0, 0, 6634, 6635, 1, 0, 0, 0, 6635, 1131, 1, 0, 0, + 0, 6636, 6642, 5, 297, 0, 0, 6637, 6638, 5, 298, 0, 0, 6638, 6639, 3, 952, + 476, 0, 6639, 6640, 5, 299, 0, 0, 6640, 6641, 3, 952, 476, 0, 6641, 6643, + 1, 0, 0, 0, 6642, 6637, 1, 0, 0, 0, 6643, 6644, 1, 0, 0, 0, 6644, 6642, + 1, 0, 0, 0, 6644, 6645, 1, 0, 0, 0, 6645, 1133, 1, 0, 0, 0, 6646, 6647, + 3, 1208, 604, 0, 6647, 6648, 3, 1138, 569, 0, 6648, 6652, 1, 0, 0, 0, 6649, + 6650, 5, 96, 0, 0, 6650, 6652, 3, 1138, 569, 0, 6651, 6646, 1, 0, 0, 0, + 6651, 6649, 1, 0, 0, 0, 6652, 1135, 1, 0, 0, 0, 6653, 6654, 5, 295, 0, + 0, 6654, 6655, 3, 1196, 598, 0, 6655, 6656, 3, 1152, 576, 0, 6656, 1137, + 1, 0, 0, 0, 6657, 6658, 3, 1140, 570, 0, 6658, 6659, 5, 20, 0, 0, 6659, + 6666, 1, 0, 0, 0, 6660, 6661, 3, 1142, 571, 0, 6661, 6662, 5, 20, 0, 0, + 6662, 6663, 5, 17, 0, 0, 6663, 6664, 5, 20, 0, 0, 6664, 6666, 1, 0, 0, + 0, 6665, 6657, 1, 0, 0, 0, 6665, 6660, 1, 0, 0, 0, 6666, 1139, 1, 0, 0, + 0, 6667, 6668, 5, 20, 0, 0, 6668, 1141, 1, 0, 0, 0, 6669, 6670, 6, 571, + -1, 0, 6670, 6671, 3, 1140, 570, 0, 6671, 6672, 3, 1144, 572, 0, 6672, + 6677, 1, 0, 0, 0, 6673, 6674, 3, 1140, 570, 0, 6674, 6675, 3, 1150, 575, + 0, 6675, 6677, 1, 0, 0, 0, 6676, 6669, 1, 0, 0, 0, 6676, 6673, 1, 0, 0, + 0, 6677, 6688, 1, 0, 0, 0, 6678, 6679, 10, 3, 0, 0, 6679, 6680, 5, 17, + 0, 0, 6680, 6687, 3, 1144, 572, 0, 6681, 6682, 10, 2, 0, 0, 6682, 6687, + 3, 1144, 572, 0, 6683, 6684, 10, 1, 0, 0, 6684, 6685, 5, 17, 0, 0, 6685, + 6687, 3, 1150, 575, 0, 6686, 6678, 1, 0, 0, 0, 6686, 6681, 1, 0, 0, 0, + 6686, 6683, 1, 0, 0, 0, 6687, 6690, 1, 0, 0, 0, 6688, 6686, 1, 0, 0, 0, + 6688, 6689, 1, 0, 0, 0, 6689, 1143, 1, 0, 0, 0, 6690, 6688, 1, 0, 0, 0, + 6691, 6692, 3, 1146, 573, 0, 6692, 6693, 3, 1148, 574, 0, 6693, 1145, 1, + 0, 0, 0, 6694, 6695, 3, 1106, 553, 0, 6695, 1147, 1, 0, 0, 0, 6696, 6697, + 5, 26, 0, 0, 6697, 6700, 3, 952, 476, 0, 6698, 6700, 3, 1138, 569, 0, 6699, + 6696, 1, 0, 0, 0, 6699, 6698, 1, 0, 0, 0, 6700, 1149, 1, 0, 0, 0, 6701, + 6702, 5, 21, 0, 0, 6702, 6703, 3, 1198, 599, 0, 6703, 6704, 5, 22, 0, 0, + 6704, 1151, 1, 0, 0, 0, 6705, 6706, 3, 1154, 577, 0, 6706, 6707, 5, 22, + 0, 0, 6707, 6712, 1, 0, 0, 0, 6708, 6709, 3, 1156, 578, 0, 6709, 6710, + 5, 22, 0, 0, 6710, 6712, 1, 0, 0, 0, 6711, 6705, 1, 0, 0, 0, 6711, 6708, + 1, 0, 0, 0, 6712, 1153, 1, 0, 0, 0, 6713, 6714, 3, 1156, 578, 0, 6714, + 6719, 3, 1158, 579, 0, 6715, 6716, 5, 17, 0, 0, 6716, 6718, 3, 1158, 579, + 0, 6717, 6715, 1, 0, 0, 0, 6718, 6721, 1, 0, 0, 0, 6719, 6717, 1, 0, 0, + 0, 6719, 6720, 1, 0, 0, 0, 6720, 1155, 1, 0, 0, 0, 6721, 6719, 1, 0, 0, + 0, 6722, 6723, 5, 295, 0, 0, 6723, 6724, 3, 1196, 598, 0, 6724, 6725, 5, + 21, 0, 0, 6725, 1157, 1, 0, 0, 0, 6726, 6738, 3, 952, 476, 0, 6727, 6728, + 3, 952, 476, 0, 6728, 6729, 5, 58, 0, 0, 6729, 6730, 3, 1200, 600, 0, 6730, + 6738, 1, 0, 0, 0, 6731, 6732, 3, 952, 476, 0, 6732, 6733, 5, 58, 0, 0, + 6733, 6734, 5, 21, 0, 0, 6734, 6735, 3, 1198, 599, 0, 6735, 6736, 5, 22, + 0, 0, 6736, 6738, 1, 0, 0, 0, 6737, 6726, 1, 0, 0, 0, 6737, 6727, 1, 0, + 0, 0, 6737, 6731, 1, 0, 0, 0, 6738, 1159, 1, 0, 0, 0, 6739, 6740, 3, 1164, + 582, 0, 6740, 6741, 5, 24, 0, 0, 6741, 6746, 1, 0, 0, 0, 6742, 6743, 3, + 1162, 581, 0, 6743, 6744, 5, 24, 0, 0, 6744, 6746, 1, 0, 0, 0, 6745, 6739, + 1, 0, 0, 0, 6745, 6742, 1, 0, 0, 0, 6746, 1161, 1, 0, 0, 0, 6747, 6748, + 3, 1164, 582, 0, 6748, 6753, 3, 952, 476, 0, 6749, 6750, 5, 17, 0, 0, 6750, + 6752, 3, 952, 476, 0, 6751, 6749, 1, 0, 0, 0, 6752, 6755, 1, 0, 0, 0, 6753, + 6751, 1, 0, 0, 0, 6753, 6754, 1, 0, 0, 0, 6754, 1163, 1, 0, 0, 0, 6755, + 6753, 1, 0, 0, 0, 6756, 6757, 5, 56, 0, 0, 6757, 6763, 5, 23, 0, 0, 6758, + 6763, 5, 23, 0, 0, 6759, 6760, 3, 1214, 607, 0, 6760, 6761, 5, 23, 0, 0, + 6761, 6763, 1, 0, 0, 0, 6762, 6756, 1, 0, 0, 0, 6762, 6758, 1, 0, 0, 0, + 6762, 6759, 1, 0, 0, 0, 6763, 1165, 1, 0, 0, 0, 6764, 6765, 3, 1168, 584, + 0, 6765, 6766, 3, 1244, 622, 0, 6766, 1167, 1, 0, 0, 0, 6767, 6768, 5, + 119, 0, 0, 6768, 6769, 3, 1216, 608, 0, 6769, 6770, 3, 1170, 585, 0, 6770, + 6771, 3, 1218, 609, 0, 6771, 1169, 1, 0, 0, 0, 6772, 6774, 3, 1188, 594, + 0, 6773, 6775, 3, 1182, 591, 0, 6774, 6773, 1, 0, 0, 0, 6774, 6775, 1, + 0, 0, 0, 6775, 6777, 1, 0, 0, 0, 6776, 6778, 3, 1172, 586, 0, 6777, 6776, + 1, 0, 0, 0, 6777, 6778, 1, 0, 0, 0, 6778, 1171, 1, 0, 0, 0, 6779, 6780, + 5, 303, 0, 0, 6780, 6781, 3, 1174, 587, 0, 6781, 1173, 1, 0, 0, 0, 6782, + 6786, 3, 1244, 622, 0, 6783, 6786, 3, 1178, 589, 0, 6784, 6786, 3, 1176, + 588, 0, 6785, 6782, 1, 0, 0, 0, 6785, 6783, 1, 0, 0, 0, 6785, 6784, 1, + 0, 0, 0, 6786, 1175, 1, 0, 0, 0, 6787, 6788, 5, 35, 0, 0, 6788, 6789, 3, + 1198, 599, 0, 6789, 1177, 1, 0, 0, 0, 6790, 6793, 3, 1180, 590, 0, 6791, + 6793, 5, 33, 0, 0, 6792, 6790, 1, 0, 0, 0, 6792, 6791, 1, 0, 0, 0, 6793, + 1179, 1, 0, 0, 0, 6794, 6795, 5, 34, 0, 0, 6795, 6796, 3, 1200, 600, 0, + 6796, 1181, 1, 0, 0, 0, 6797, 6798, 3, 1184, 592, 0, 6798, 6799, 5, 22, + 0, 0, 6799, 6806, 1, 0, 0, 0, 6800, 6801, 3, 1184, 592, 0, 6801, 6802, + 5, 17, 0, 0, 6802, 6803, 5, 22, 0, 0, 6803, 6804, 6, 591, -1, 0, 6804, + 6806, 1, 0, 0, 0, 6805, 6797, 1, 0, 0, 0, 6805, 6800, 1, 0, 0, 0, 6806, + 1183, 1, 0, 0, 0, 6807, 6808, 5, 21, 0, 0, 6808, 6813, 3, 1186, 593, 0, + 6809, 6810, 5, 17, 0, 0, 6810, 6812, 3, 1186, 593, 0, 6811, 6809, 1, 0, + 0, 0, 6812, 6815, 1, 0, 0, 0, 6813, 6811, 1, 0, 0, 0, 6813, 6814, 1, 0, + 0, 0, 6814, 1185, 1, 0, 0, 0, 6815, 6813, 1, 0, 0, 0, 6816, 6823, 3, 1236, + 618, 0, 6817, 6823, 3, 1242, 621, 0, 6818, 6823, 3, 1244, 622, 0, 6819, + 6823, 3, 1238, 619, 0, 6820, 6823, 3, 1224, 612, 0, 6821, 6823, 5, 208, + 0, 0, 6822, 6816, 1, 0, 0, 0, 6822, 6817, 1, 0, 0, 0, 6822, 6818, 1, 0, + 0, 0, 6822, 6819, 1, 0, 0, 0, 6822, 6820, 1, 0, 0, 0, 6822, 6821, 1, 0, + 0, 0, 6823, 1187, 1, 0, 0, 0, 6824, 6831, 3, 1214, 607, 0, 6825, 6831, + 3, 1208, 604, 0, 6826, 6831, 3, 1196, 598, 0, 6827, 6831, 3, 1168, 584, + 0, 6828, 6831, 3, 1192, 596, 0, 6829, 6831, 3, 1190, 595, 0, 6830, 6824, + 1, 0, 0, 0, 6830, 6825, 1, 0, 0, 0, 6830, 6826, 1, 0, 0, 0, 6830, 6827, + 1, 0, 0, 0, 6830, 6828, 1, 0, 0, 0, 6830, 6829, 1, 0, 0, 0, 6831, 1189, + 1, 0, 0, 0, 6832, 6833, 5, 203, 0, 0, 6833, 6834, 3, 1216, 608, 0, 6834, + 6835, 3, 1170, 585, 0, 6835, 6836, 5, 17, 0, 0, 6836, 6837, 3, 1170, 585, + 0, 6837, 6838, 3, 1218, 609, 0, 6838, 1191, 1, 0, 0, 0, 6839, 6840, 5, + 178, 0, 0, 6840, 6841, 3, 1216, 608, 0, 6841, 6842, 5, 21, 0, 0, 6842, + 6843, 5, 22, 0, 0, 6843, 6844, 5, 37, 0, 0, 6844, 6845, 3, 1170, 585, 0, + 6845, 6846, 3, 1218, 609, 0, 6846, 6861, 1, 0, 0, 0, 6847, 6848, 5, 178, + 0, 0, 6848, 6849, 3, 1216, 608, 0, 6849, 6850, 3, 1170, 585, 0, 6850, 6851, + 5, 37, 0, 0, 6851, 6852, 3, 1170, 585, 0, 6852, 6853, 3, 1218, 609, 0, + 6853, 6861, 1, 0, 0, 0, 6854, 6855, 3, 1194, 597, 0, 6855, 6856, 5, 22, + 0, 0, 6856, 6857, 5, 37, 0, 0, 6857, 6858, 3, 1170, 585, 0, 6858, 6859, + 3, 1218, 609, 0, 6859, 6861, 1, 0, 0, 0, 6860, 6839, 1, 0, 0, 0, 6860, + 6847, 1, 0, 0, 0, 6860, 6854, 1, 0, 0, 0, 6861, 1193, 1, 0, 0, 0, 6862, + 6863, 5, 178, 0, 0, 6863, 6864, 3, 1216, 608, 0, 6864, 6865, 5, 21, 0, + 0, 6865, 6870, 3, 1170, 585, 0, 6866, 6867, 5, 17, 0, 0, 6867, 6869, 3, + 1170, 585, 0, 6868, 6866, 1, 0, 0, 0, 6869, 6872, 1, 0, 0, 0, 6870, 6868, + 1, 0, 0, 0, 6870, 6871, 1, 0, 0, 0, 6871, 1195, 1, 0, 0, 0, 6872, 6870, + 1, 0, 0, 0, 6873, 6876, 3, 1198, 599, 0, 6874, 6876, 5, 120, 0, 0, 6875, + 6873, 1, 0, 0, 0, 6875, 6874, 1, 0, 0, 0, 6876, 1197, 1, 0, 0, 0, 6877, + 6882, 3, 1200, 600, 0, 6878, 6879, 5, 18, 0, 0, 6879, 6881, 3, 1200, 600, + 0, 6880, 6878, 1, 0, 0, 0, 6881, 6884, 1, 0, 0, 0, 6882, 6880, 1, 0, 0, + 0, 6882, 6883, 1, 0, 0, 0, 6883, 1199, 1, 0, 0, 0, 6884, 6882, 1, 0, 0, + 0, 6885, 6888, 3, 1206, 603, 0, 6886, 6888, 3, 1202, 601, 0, 6887, 6885, + 1, 0, 0, 0, 6887, 6886, 1, 0, 0, 0, 6888, 1201, 1, 0, 0, 0, 6889, 6892, + 3, 1204, 602, 0, 6890, 6892, 5, 121, 0, 0, 6891, 6889, 1, 0, 0, 0, 6891, + 6890, 1, 0, 0, 0, 6892, 1203, 1, 0, 0, 0, 6893, 6894, 7, 34, 0, 0, 6894, + 1205, 1, 0, 0, 0, 6895, 6896, 5, 364, 0, 0, 6896, 1207, 1, 0, 0, 0, 6897, + 6898, 5, 96, 0, 0, 6898, 6899, 3, 1216, 608, 0, 6899, 6900, 3, 1218, 609, + 0, 6900, 6905, 1, 0, 0, 0, 6901, 6902, 3, 1210, 605, 0, 6902, 6903, 3, + 1218, 609, 0, 6903, 6905, 1, 0, 0, 0, 6904, 6897, 1, 0, 0, 0, 6904, 6901, + 1, 0, 0, 0, 6905, 1209, 1, 0, 0, 0, 6906, 6907, 5, 96, 0, 0, 6907, 6908, + 3, 1216, 608, 0, 6908, 6913, 3, 1212, 606, 0, 6909, 6910, 5, 17, 0, 0, + 6910, 6912, 3, 1212, 606, 0, 6911, 6909, 1, 0, 0, 0, 6912, 6915, 1, 0, + 0, 0, 6913, 6911, 1, 0, 0, 0, 6913, 6914, 1, 0, 0, 0, 6914, 1211, 1, 0, + 0, 0, 6915, 6913, 1, 0, 0, 0, 6916, 6917, 3, 1200, 600, 0, 6917, 6918, + 3, 1170, 585, 0, 6918, 6921, 1, 0, 0, 0, 6919, 6921, 3, 1170, 585, 0, 6920, + 6916, 1, 0, 0, 0, 6920, 6919, 1, 0, 0, 0, 6921, 1213, 1, 0, 0, 0, 6922, + 6923, 5, 56, 0, 0, 6923, 6924, 3, 1216, 608, 0, 6924, 6925, 3, 1170, 585, + 0, 6925, 6926, 3, 1218, 609, 0, 6926, 1215, 1, 0, 0, 0, 6927, 6928, 5, + 4, 0, 0, 6928, 1217, 1, 0, 0, 0, 6929, 6930, 5, 6, 0, 0, 6930, 1219, 1, + 0, 0, 0, 6931, 6932, 3, 1222, 611, 0, 6932, 6933, 3, 1244, 622, 0, 6933, + 1221, 1, 0, 0, 0, 6934, 6935, 7, 35, 0, 0, 6935, 1223, 1, 0, 0, 0, 6936, + 6937, 5, 54, 0, 0, 6937, 1225, 1, 0, 0, 0, 6938, 6939, 5, 114, 0, 0, 6939, + 6940, 3, 1244, 622, 0, 6940, 1227, 1, 0, 0, 0, 6941, 6942, 3, 1230, 615, + 0, 6942, 6943, 3, 1244, 622, 0, 6943, 1229, 1, 0, 0, 0, 6944, 6945, 7, + 36, 0, 0, 6945, 1231, 1, 0, 0, 0, 6946, 6947, 3, 1234, 617, 0, 6947, 6948, + 3, 1244, 622, 0, 6948, 1233, 1, 0, 0, 0, 6949, 6950, 7, 37, 0, 0, 6950, + 1235, 1, 0, 0, 0, 6951, 6952, 5, 55, 0, 0, 6952, 1237, 1, 0, 0, 0, 6953, + 6954, 6, 619, -1, 0, 6954, 6955, 3, 1248, 624, 0, 6955, 6966, 1, 0, 0, + 0, 6956, 6957, 10, 2, 0, 0, 6957, 6958, 3, 1248, 624, 0, 6958, 6959, 6, + 619, -1, 0, 6959, 6965, 1, 0, 0, 0, 6960, 6961, 10, 1, 0, 0, 6961, 6962, + 3, 1246, 623, 0, 6962, 6963, 6, 619, -1, 0, 6963, 6965, 1, 0, 0, 0, 6964, + 6956, 1, 0, 0, 0, 6964, 6960, 1, 0, 0, 0, 6965, 6968, 1, 0, 0, 0, 6966, + 6964, 1, 0, 0, 0, 6966, 6967, 1, 0, 0, 0, 6967, 1239, 1, 0, 0, 0, 6968, + 6966, 1, 0, 0, 0, 6969, 6970, 5, 80, 0, 0, 6970, 1241, 1, 0, 0, 0, 6971, + 6972, 7, 38, 0, 0, 6972, 1243, 1, 0, 0, 0, 6973, 6974, 6, 622, -1, 0, 6974, + 6975, 3, 1246, 623, 0, 6975, 6986, 1, 0, 0, 0, 6976, 6977, 10, 2, 0, 0, + 6977, 6978, 3, 1246, 623, 0, 6978, 6979, 6, 622, -1, 0, 6979, 6985, 1, + 0, 0, 0, 6980, 6981, 10, 1, 0, 0, 6981, 6982, 3, 1248, 624, 0, 6982, 6983, + 6, 622, -1, 0, 6983, 6985, 1, 0, 0, 0, 6984, 6976, 1, 0, 0, 0, 6984, 6980, + 1, 0, 0, 0, 6985, 6988, 1, 0, 0, 0, 6986, 6984, 1, 0, 0, 0, 6986, 6987, + 1, 0, 0, 0, 6987, 1245, 1, 0, 0, 0, 6988, 6986, 1, 0, 0, 0, 6989, 6990, + 5, 44, 0, 0, 6990, 1247, 1, 0, 0, 0, 6991, 6992, 5, 45, 0, 0, 6992, 1249, + 1, 0, 0, 0, 850, 1258, 1262, 1265, 1276, 1331, 1342, 1347, 1357, 1364, + 1371, 1382, 1390, 1396, 1403, 1405, 1412, 1417, 1421, 1424, 1428, 1438, + 1448, 1458, 1464, 1470, 1475, 1480, 1484, 1487, 1490, 1496, 1501, 1506, + 1511, 1522, 1526, 1530, 1534, 1540, 1543, 1561, 1568, 1571, 1574, 1577, + 1580, 1584, 1589, 1593, 1598, 1606, 1619, 1625, 1633, 1635, 1641, 1651, + 1659, 1666, 1670, 1673, 1677, 1680, 1683, 1701, 1705, 1713, 1718, 1721, + 1724, 1729, 1736, 1742, 1745, 1750, 1754, 1757, 1762, 1768, 1771, 1778, + 1790, 1793, 1801, 1814, 1823, 1827, 1832, 1836, 1842, 1848, 1855, 1859, + 1862, 1864, 1872, 1881, 1884, 1892, 1905, 1907, 1918, 1920, 1928, 1931, + 1939, 1942, 1948, 1951, 1959, 1962, 1971, 1974, 1987, 1993, 1999, 2003, + 2014, 2018, 2022, 2026, 2029, 2036, 2039, 2042, 2046, 2050, 2053, 2056, + 2062, 2066, 2070, 2074, 2077, 2080, 2083, 2086, 2093, 2097, 2101, 2105, + 2108, 2111, 2115, 2121, 2129, 2136, 2140, 2143, 2147, 2151, 2154, 2157, + 2160, 2163, 2166, 2169, 2172, 2175, 2178, 2181, 2184, 2198, 2201, 2208, + 2223, 2226, 2231, 2235, 2238, 2241, 2244, 2247, 2254, 2258, 2262, 2264, + 2272, 2275, 2281, 2286, 2289, 2295, 2299, 2302, 2307, 2311, 2317, 2321, + 2325, 2328, 2332, 2339, 2345, 2357, 2361, 2367, 2370, 2373, 2376, 2379, + 2383, 2388, 2391, 2396, 2402, 2409, 2416, 2421, 2428, 2439, 2447, 2454, + 2457, 2461, 2465, 2468, 2471, 2474, 2477, 2495, 2502, 2510, 2513, 2522, + 2525, 2530, 2534, 2537, 2540, 2543, 2546, 2556, 2560, 2564, 2567, 2572, + 2577, 2587, 2591, 2596, 2604, 2616, 2619, 2625, 2628, 2631, 2634, 2638, + 2643, 2646, 2650, 2653, 2657, 2660, 2664, 2680, 2691, 2697, 2703, 2718, + 2725, 2728, 2731, 2734, 2739, 2743, 2746, 2757, 2760, 2764, 2769, 2772, + 2775, 2783, 2785, 2789, 2792, 2810, 2815, 2829, 2831, 2840, 2848, 2855, + 2866, 2875, 2886, 2892, 2896, 2898, 2904, 2911, 2915, 2919, 2921, 2925, + 2929, 2938, 2942, 2948, 2951, 2954, 2963, 2967, 2971, 2988, 2991, 2996, + 3002, 3008, 3016, 3019, 3022, 3026, 3030, 3033, 3036, 3039, 3042, 3050, + 3062, 3071, 3075, 3079, 3081, 3086, 3090, 3092, 3099, 3102, 3121, 3124, + 3131, 3134, 3137, 3141, 3144, 3146, 3157, 3166, 3175, 3185, 3193, 3197, + 3201, 3205, 3209, 3212, 3216, 3236, 3240, 3244, 3278, 3285, 3290, 3296, + 3298, 3305, 3320, 3326, 3330, 3334, 3343, 3347, 3352, 3360, 3363, 3373, + 3377, 3381, 3388, 3393, 3408, 3413, 3416, 3419, 3424, 3427, 3430, 3433, + 3437, 3441, 3444, 3447, 3450, 3453, 3456, 3460, 3464, 3467, 3471, 3476, + 3479, 3483, 3490, 3493, 3495, 3500, 3507, 3514, 3516, 3526, 3533, 3538, + 3550, 3557, 3561, 3563, 3581, 3588, 3596, 3605, 3612, 3616, 3619, 3623, + 3627, 3640, 3645, 3653, 3661, 3669, 3677, 3690, 3706, 3710, 3713, 3718, + 3725, 3728, 3731, 3734, 3737, 3740, 3744, 3759, 3764, 3767, 3774, 3780, + 3793, 3797, 3811, 3819, 3823, 3825, 3831, 3839, 3851, 3856, 3863, 3885, + 3898, 3906, 3911, 3919, 3944, 3951, 3967, 3975, 3982, 3987, 3995, 4005, + 4009, 4012, 4017, 4023, 4032, 4043, 4053, 4063, 4072, 4082, 4099, 4110, + 4121, 4126, 4134, 4141, 4147, 4157, 4162, 4165, 4168, 4188, 4193, 4196, + 4201, 4204, 4210, 4216, 4227, 4230, 4233, 4237, 4243, 4247, 4261, 4266, + 4271, 4274, 4277, 4280, 4283, 4304, 4314, 4319, 4331, 4335, 4341, 4355, + 4358, 4364, 4367, 4372, 4376, 4385, 4388, 4391, 4400, 4410, 4413, 4421, + 4424, 4430, 4433, 4440, 4443, 4450, 4453, 4455, 4461, 4464, 4468, 4472, + 4474, 4490, 4499, 4507, 4516, 4522, 4529, 4536, 4539, 4551, 4554, 4557, + 4563, 4570, 4576, 4589, 4598, 4605, 4614, 4623, 4625, 4628, 4632, 4636, + 4639, 4644, 4654, 4659, 4661, 4667, 4674, 4681, 4688, 4693, 4703, 4707, + 4711, 4716, 4722, 4730, 4735, 4738, 4741, 4745, 4748, 4752, 4755, 4758, + 4761, 4764, 4768, 4771, 4774, 4777, 4781, 4784, 4788, 4791, 4801, 4816, + 4823, 4826, 4829, 4832, 4837, 4840, 4843, 4846, 4850, 4856, 4865, 4874, + 4883, 4888, 4891, 4894, 4898, 4902, 4904, 4914, 4920, 4922, 4928, 4931, + 4936, 4939, 4941, 4950, 4956, 4977, 4981, 4986, 4989, 5004, 5010, 5017, + 5019, 5028, 5036, 5043, 5047, 5058, 5064, 5077, 5087, 5097, 5105, 5112, + 5121, 5127, 5131, 5134, 5137, 5141, 5145, 5150, 5154, 5163, 5172, 5175, + 5178, 5181, 5194, 5199, 5208, 5214, 5224, 5229, 5237, 5241, 5246, 5268, + 5272, 5276, 5286, 5303, 5316, 5318, 5335, 5337, 5342, 5354, 5358, 5366, + 5375, 5383, 5391, 5424, 5431, 5443, 5452, 5462, 5484, 5489, 5492, 5496, + 5499, 5506, 5513, 5520, 5538, 5543, 5550, 5555, 5560, 5565, 5570, 5574, + 5576, 5588, 5592, 5597, 5601, 5608, 5614, 5618, 5621, 5630, 5642, 5654, + 5661, 5700, 5762, 5770, 5777, 5785, 5807, 5809, 5862, 5870, 5885, 5893, + 5961, 5971, 5985, 5988, 5993, 5999, 6017, 6026, 6037, 6045, 6051, 6054, + 6065, 6073, 6078, 6088, 6096, 6103, 6108, 6116, 6119, 6122, 6125, 6130, + 6136, 6140, 6143, 6146, 6149, 6152, 6155, 6158, 6161, 6164, 6167, 6175, + 6178, 6181, 6184, 6187, 6198, 6207, 6217, 6225, 6248, 6256, 6265, 6273, + 6277, 6284, 6297, 6306, 6315, 6325, 6333, 6338, 6341, 6351, 6360, 6368, + 6381, 6385, 6393, 6396, 6407, 6417, 6429, 6437, 6447, 6455, 6459, 6467, + 6483, 6494, 6510, 6512, 6529, 6531, 6546, 6563, 6574, 6587, 6601, 6609, + 6619, 6623, 6634, 6644, 6651, 6665, 6676, 6686, 6688, 6699, 6711, 6719, + 6737, 6745, 6753, 6762, 6774, 6777, 6785, 6792, 6805, 6813, 6822, 6830, + 6860, 6870, 6875, 6882, 6887, 6891, 6904, 6913, 6920, 6964, 6966, 6984, + 6986, + } + deserializer := antlr.NewATNDeserializer(nil) + staticData.atn = deserializer.Deserialize(staticData.serializedATN) + atn := staticData.atn + staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState)) + decisionToDFA := staticData.decisionToDFA + for index, state := range atn.DecisionToState { + decisionToDFA[index] = antlr.NewDFA(state, index) + } +} + +// GoogleSQLParserInit initializes any static state used to implement GoogleSQLParser. By default the +// static state used to implement the parser is lazily initialized during the first call to +// NewGoogleSQLParser(). You can call this function if you wish to initialize the static state ahead +// of time. +func GoogleSQLParserInit() { + staticData := &GoogleSQLParserParserStaticData + staticData.once.Do(googlesqlparserParserInit) +} + +// NewGoogleSQLParser produces a new parser instance for the optional input antlr.TokenStream. +func NewGoogleSQLParser(input antlr.TokenStream) *GoogleSQLParser { + GoogleSQLParserInit() + this := new(GoogleSQLParser) + this.BaseParser = antlr.NewBaseParser(input) + staticData := &GoogleSQLParserParserStaticData + 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 = "GoogleSQLParser.g4" + + return this +} + +// GoogleSQLParser tokens. +const ( + GoogleSQLParserEOF = antlr.TokenEOF + GoogleSQLParserEQUAL_OPERATOR = 1 + GoogleSQLParserNOT_EQUAL_OPERATOR = 2 + GoogleSQLParserNOT_EQUAL2_OPERATOR = 3 + GoogleSQLParserLT_OPERATOR = 4 + GoogleSQLParserLE_OPERATOR = 5 + GoogleSQLParserGT_OPERATOR = 6 + GoogleSQLParserGE_OPERATOR = 7 + GoogleSQLParserKL_OPERATOR = 8 + GoogleSQLParserKR_OPERATOR = 9 + GoogleSQLParserPLUS_OPERATOR = 10 + GoogleSQLParserMINUS_OPERATOR = 11 + GoogleSQLParserMULTIPLY_OPERATOR = 12 + GoogleSQLParserDIVIDE_OPERATOR = 13 + GoogleSQLParserBITWISE_NOT_OPERATOR = 14 + GoogleSQLParserEXCLAMATION_OPERATOR = 15 + GoogleSQLParserMODULO_OPERATOR = 16 + GoogleSQLParserCOMMA_SYMBOL = 17 + GoogleSQLParserDOT_SYMBOL = 18 + GoogleSQLParserLC_BRACKET_SYMBOL = 19 + GoogleSQLParserRC_BRACKET_SYMBOL = 20 + GoogleSQLParserLR_BRACKET_SYMBOL = 21 + GoogleSQLParserRR_BRACKET_SYMBOL = 22 + GoogleSQLParserLS_BRACKET_SYMBOL = 23 + GoogleSQLParserRS_BRACKET_SYMBOL = 24 + GoogleSQLParserSTROKE_SYMBOL = 25 + GoogleSQLParserCOLON_SYMBOL = 26 + GoogleSQLParserSEMI_SYMBOL = 27 + GoogleSQLParserSINGLE_QUOTE_SYMBOL = 28 + GoogleSQLParserSINGLE_QUOTE_3_SYMBOL = 29 + GoogleSQLParserDOUBLE_QUOTE_SYMBOL = 30 + GoogleSQLParserDOUBLE_QUOTE_3_SYMBOL = 31 + GoogleSQLParserBACKQUOTE_SYMBOL = 32 + GoogleSQLParserQUESTION_SYMBOL = 33 + GoogleSQLParserAT_SYMBOL = 34 + GoogleSQLParserATAT_SYMBOL = 35 + GoogleSQLParserEQUAL_GT_BRACKET_SYMBOL = 36 + GoogleSQLParserSUB_GT_BRACKET_SYMBOL = 37 + GoogleSQLParserPLUS_EQUAL_SYMBOL = 38 + GoogleSQLParserSUB_EQUAL_SYMBOL = 39 + GoogleSQLParserPIPE_SYMBOL = 40 + GoogleSQLParserCIRCUMFLEX_SYMBOL = 41 + GoogleSQLParserBIT_AND_SYMBOL = 42 + GoogleSQLParserBOOL_OR_SYMBOL = 43 + GoogleSQLParserSTRING_LITERAL = 44 + GoogleSQLParserBYTES_LITERAL = 45 + GoogleSQLParserUNCLOSED_STRING_LITERAL = 46 + GoogleSQLParserUNCLOSED_TRIPLE_QUOTED_STRING_LITERAL = 47 + GoogleSQLParserUNCLOSED_RAW_STRING_LITERAL = 48 + GoogleSQLParserUNCLOSED_TRIPLE_QUOTED_RAW_STRING_LITERAL = 49 + GoogleSQLParserUNCLOSED_BYTES_LITERAL = 50 + GoogleSQLParserUNCLOSED_TRIPLE_QUOTED_BYTES_LITERAL = 51 + GoogleSQLParserUNCLOSED_RAW_BYTES_LITERAL = 52 + GoogleSQLParserUNCLOSED_TRIPLE_QUOTED_RAW_BYTES_LITERAL = 53 + GoogleSQLParserFLOATING_POINT_LITERAL = 54 + GoogleSQLParserINTEGER_LITERAL = 55 + GoogleSQLParserARRAY_SYMBOL = 56 + GoogleSQLParserALL_SYMBOL = 57 + GoogleSQLParserAS_SYMBOL = 58 + GoogleSQLParserASC_SYMBOL = 59 + GoogleSQLParserBY_SYMBOL = 60 + GoogleSQLParserCROSS_SYMBOL = 61 + GoogleSQLParserJOIN_SYMBOL = 62 + GoogleSQLParserDELTA_SYMBOL = 63 + GoogleSQLParserDESC_SYMBOL = 64 + GoogleSQLParserDIFFERENTIAL_PRIVACY_SYMBOL = 65 + GoogleSQLParserDISTINCT_SYMBOL = 66 + GoogleSQLParserEPSILON_SYMBOL = 67 + GoogleSQLParserEXCEPT_SYMBOL = 68 + GoogleSQLParserEXCLUDE_SYMBOL = 69 + GoogleSQLParserFOR_SYMBOL = 70 + GoogleSQLParserFROM_SYMBOL = 71 + GoogleSQLParserFULL_SYMBOL = 72 + GoogleSQLParserIN_SYMBOL = 73 + GoogleSQLParserINCLUDE_SYMBOL = 74 + GoogleSQLParserINNER_SYMBOL = 75 + GoogleSQLParserINTERSECT_SYMBOL = 76 + GoogleSQLParserLEFT_SYMBOL = 77 + GoogleSQLParserLIMIT_SYMBOL = 78 + GoogleSQLParserMAX_GROUPS_CONTRIBUTED_SYMBOL = 79 + GoogleSQLParserNULL_SYMBOL = 80 + GoogleSQLParserNULLS_SYMBOL = 81 + GoogleSQLParserOF_SYMBOL = 82 + GoogleSQLParserOFFSET_SYMBOL = 83 + GoogleSQLParserON_SYMBOL = 84 + GoogleSQLParserOPTIONS_SYMBOL = 85 + GoogleSQLParserORDER_SYMBOL = 86 + GoogleSQLParserOUTER_SYMBOL = 87 + GoogleSQLParserPERCENT_SYMBOL = 88 + GoogleSQLParserPIVOT_SYMBOL = 89 + GoogleSQLParserPRIVACY_UNIT_COLUMN_SYMBOL = 90 + GoogleSQLParserRIGHT_SYMBOL = 91 + GoogleSQLParserRECURSIVE_SYMBOL = 92 + GoogleSQLParserREPLACE_SYMBOL = 93 + GoogleSQLParserUNPIVOT_SYMBOL = 94 + GoogleSQLParserSELECT_SYMBOL = 95 + GoogleSQLParserSTRUCT_SYMBOL = 96 + GoogleSQLParserSYSTEM_SYMBOL = 97 + GoogleSQLParserSYSTEM_TIME_SYMBOL = 98 + GoogleSQLParserTABLESAMPLE_SYMBOL = 99 + GoogleSQLParserUNION_SYMBOL = 100 + GoogleSQLParserUNNEST_SYMBOL = 101 + GoogleSQLParserUSING_SYMBOL = 102 + GoogleSQLParserVALUE_SYMBOL = 103 + GoogleSQLParserWITH_SYMBOL = 104 + GoogleSQLParserTRUE_SYMBOL = 105 + GoogleSQLParserFALSE_SYMBOL = 106 + GoogleSQLParserNUMERIC_SYMBOL = 107 + GoogleSQLParserDECIMAL_SYMBOL = 108 + GoogleSQLParserBIGNUMERIC_SYMBOL = 109 + GoogleSQLParserBIGDECIMAL_SYMBOL = 110 + GoogleSQLParserNOT_SYMBOL = 111 + GoogleSQLParserAND_SYMBOL = 112 + GoogleSQLParserOR_SYMBOL = 113 + GoogleSQLParserJSON_SYMBOL = 114 + GoogleSQLParserDATE_SYMBOL = 115 + GoogleSQLParserTIME_SYMBOL = 116 + GoogleSQLParserDATETIME_SYMBOL = 117 + GoogleSQLParserTIMESTAMP_SYMBOL = 118 + GoogleSQLParserRANGE_SYMBOL = 119 + GoogleSQLParserINTERVAL_SYMBOL = 120 + GoogleSQLParserSIMPLE_SYMBOL = 121 + GoogleSQLParserABORT_SYMBOL = 122 + GoogleSQLParserACCESS_SYMBOL = 123 + GoogleSQLParserACTION_SYMBOL = 124 + GoogleSQLParserAGGREGATE_SYMBOL = 125 + GoogleSQLParserADD_SYMBOL = 126 + GoogleSQLParserALTER_SYMBOL = 127 + GoogleSQLParserALWAYS_SYMBOL = 128 + GoogleSQLParserANALYZE_SYMBOL = 129 + GoogleSQLParserAPPROX_SYMBOL = 130 + GoogleSQLParserARE_SYMBOL = 131 + GoogleSQLParserASSERT_SYMBOL = 132 + GoogleSQLParserBATCH_SYMBOL = 133 + GoogleSQLParserBEGIN_SYMBOL = 134 + GoogleSQLParserBREAK_SYMBOL = 135 + GoogleSQLParserCALL_SYMBOL = 136 + GoogleSQLParserCASCADE_SYMBOL = 137 + GoogleSQLParserCHECK_SYMBOL = 138 + GoogleSQLParserCLAMPED_SYMBOL = 139 + GoogleSQLParserCLONE_SYMBOL = 140 + GoogleSQLParserCOPY_SYMBOL = 141 + GoogleSQLParserCLUSTER_SYMBOL = 142 + GoogleSQLParserCOLUMN_SYMBOL = 143 + GoogleSQLParserCOLUMNS_SYMBOL = 144 + GoogleSQLParserCOMMIT_SYMBOL = 145 + GoogleSQLParserCONNECTION_SYMBOL = 146 + GoogleSQLParserCONSTANT_SYMBOL = 147 + GoogleSQLParserCONSTRAINT_SYMBOL = 148 + GoogleSQLParserCONTINUE_SYMBOL = 149 + GoogleSQLParserCORRESPONDING_SYMBOL = 150 + GoogleSQLParserCYCLE_SYMBOL = 151 + GoogleSQLParserDATA_SYMBOL = 152 + GoogleSQLParserDATABASE_SYMBOL = 153 + GoogleSQLParserDECLARE_SYMBOL = 154 + GoogleSQLParserDEFINER_SYMBOL = 155 + GoogleSQLParserDELETE_SYMBOL = 156 + GoogleSQLParserDELETION_SYMBOL = 157 + GoogleSQLParserDEPTH_SYMBOL = 158 + GoogleSQLParserDESCRIBE_SYMBOL = 159 + GoogleSQLParserDETERMINISTIC_SYMBOL = 160 + GoogleSQLParserDO_SYMBOL = 161 + GoogleSQLParserDROP_SYMBOL = 162 + GoogleSQLParserELSEIF_SYMBOL = 163 + GoogleSQLParserENFORCED_SYMBOL = 164 + GoogleSQLParserERROR_SYMBOL = 165 + GoogleSQLParserEXCEPTION_SYMBOL = 166 + GoogleSQLParserEXECUTE_SYMBOL = 167 + GoogleSQLParserEXPLAIN_SYMBOL = 168 + GoogleSQLParserEXPORT_SYMBOL = 169 + GoogleSQLParserEXTEND_SYMBOL = 170 + GoogleSQLParserEXTERNAL_SYMBOL = 171 + GoogleSQLParserFILES_SYMBOL = 172 + GoogleSQLParserFILTER_SYMBOL = 173 + GoogleSQLParserFILL_SYMBOL = 174 + GoogleSQLParserFIRST_SYMBOL = 175 + GoogleSQLParserFOREIGN_SYMBOL = 176 + GoogleSQLParserFORMAT_SYMBOL = 177 + GoogleSQLParserFUNCTION_SYMBOL = 178 + GoogleSQLParserGENERATED_SYMBOL = 179 + GoogleSQLParserGRANT_SYMBOL = 180 + GoogleSQLParserGROUP_ROWS_SYMBOL = 181 + GoogleSQLParserHIDDEN_SYMBOL = 182 + GoogleSQLParserIDENTITY_SYMBOL = 183 + GoogleSQLParserIMMEDIATE_SYMBOL = 184 + GoogleSQLParserIMMUTABLE_SYMBOL = 185 + GoogleSQLParserIMPORT_SYMBOL = 186 + GoogleSQLParserINCREMENT_SYMBOL = 187 + GoogleSQLParserINDEX_SYMBOL = 188 + GoogleSQLParserINOUT_SYMBOL = 189 + GoogleSQLParserINPUT_SYMBOL = 190 + GoogleSQLParserINSERT_SYMBOL = 191 + GoogleSQLParserINVOKER_SYMBOL = 192 + GoogleSQLParserISOLATION_SYMBOL = 193 + GoogleSQLParserITERATE_SYMBOL = 194 + GoogleSQLParserKEY_SYMBOL = 195 + GoogleSQLParserLANGUAGE_SYMBOL = 196 + GoogleSQLParserLAST_SYMBOL = 197 + GoogleSQLParserLEAVE_SYMBOL = 198 + GoogleSQLParserLEVEL_SYMBOL = 199 + GoogleSQLParserLOAD_SYMBOL = 200 + GoogleSQLParserLOOP_SYMBOL = 201 + GoogleSQLParserMACRO_SYMBOL = 202 + GoogleSQLParserMAP_SYMBOL = 203 + GoogleSQLParserMATCH_SYMBOL = 204 + GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL = 205 + GoogleSQLParserMATCHED_SYMBOL = 206 + GoogleSQLParserMATERIALIZED_SYMBOL = 207 + GoogleSQLParserMAX_SYMBOL = 208 + GoogleSQLParserMAXVALUE_SYMBOL = 209 + GoogleSQLParserMEASURES_SYMBOL = 210 + GoogleSQLParserMESSAGE_SYMBOL = 211 + GoogleSQLParserMETADATA_SYMBOL = 212 + GoogleSQLParserMIN_SYMBOL = 213 + GoogleSQLParserMINVALUE_SYMBOL = 214 + GoogleSQLParserMODEL_SYMBOL = 215 + GoogleSQLParserMODULE_SYMBOL = 216 + GoogleSQLParserONLY_SYMBOL = 217 + GoogleSQLParserOUT_SYMBOL = 218 + GoogleSQLParserOUTPUT_SYMBOL = 219 + GoogleSQLParserOVERWRITE_SYMBOL = 220 + GoogleSQLParserPARTITIONS_SYMBOL = 221 + GoogleSQLParserPATTERN_SYMBOL = 222 + GoogleSQLParserPOLICIES_SYMBOL = 223 + GoogleSQLParserPOLICY_SYMBOL = 224 + GoogleSQLParserPRIMARY_SYMBOL = 225 + GoogleSQLParserPRIVATE_SYMBOL = 226 + GoogleSQLParserPRIVILEGE_SYMBOL = 227 + GoogleSQLParserPRIVILEGES_SYMBOL = 228 + GoogleSQLParserPROCEDURE_SYMBOL = 229 + GoogleSQLParserPROJECT_SYMBOL = 230 + GoogleSQLParserPUBLIC_SYMBOL = 231 + GoogleSQLParserRAISE_SYMBOL = 232 + GoogleSQLParserREAD_SYMBOL = 233 + GoogleSQLParserREFERENCES_SYMBOL = 234 + GoogleSQLParserREMOTE_SYMBOL = 235 + GoogleSQLParserREMOVE_SYMBOL = 236 + GoogleSQLParserRENAME_SYMBOL = 237 + GoogleSQLParserREPEAT_SYMBOL = 238 + GoogleSQLParserREPEATABLE_SYMBOL = 239 + GoogleSQLParserREPLACE_FIELDS_SYMBOL = 240 + GoogleSQLParserREPLICA_SYMBOL = 241 + GoogleSQLParserREPORT_SYMBOL = 242 + GoogleSQLParserRESTRICT_SYMBOL = 243 + GoogleSQLParserRESTRICTION_SYMBOL = 244 + GoogleSQLParserRETURNS_SYMBOL = 245 + GoogleSQLParserRETURN_SYMBOL = 246 + GoogleSQLParserREVOKE_SYMBOL = 247 + GoogleSQLParserROLLBACK_SYMBOL = 248 + GoogleSQLParserROW_SYMBOL = 249 + GoogleSQLParserRUN_SYMBOL = 250 + GoogleSQLParserSAFE_CAST_SYMBOL = 251 + GoogleSQLParserSCHEMA_SYMBOL = 252 + GoogleSQLParserSEARCH_SYMBOL = 253 + GoogleSQLParserSECURITY_SYMBOL = 254 + GoogleSQLParserSEQUENCE_SYMBOL = 255 + GoogleSQLParserSETS_SYMBOL = 256 + GoogleSQLParserSET_SYMBOL = 257 + GoogleSQLParserSHOW_SYMBOL = 258 + GoogleSQLParserSNAPSHOT_SYMBOL = 259 + GoogleSQLParserSOURCE_SYMBOL = 260 + GoogleSQLParserSQL_SYMBOL = 261 + GoogleSQLParserSTABLE_SYMBOL = 262 + GoogleSQLParserSTART_SYMBOL = 263 + GoogleSQLParserSTATIC_DESCRIBE_SYMBOL = 264 + GoogleSQLParserSTORED_SYMBOL = 265 + GoogleSQLParserSTORING_SYMBOL = 266 + GoogleSQLParserSTRICT_SYMBOL = 267 + GoogleSQLParserTABLE_SYMBOL = 268 + GoogleSQLParserTABLES_SYMBOL = 269 + GoogleSQLParserTARGET_SYMBOL = 270 + GoogleSQLParserTEMP_SYMBOL = 271 + GoogleSQLParserTEMPORARY_SYMBOL = 272 + GoogleSQLParserTRANSACTION_SYMBOL = 273 + GoogleSQLParserTRANSFORM_SYMBOL = 274 + GoogleSQLParserTRUNCATE_SYMBOL = 275 + GoogleSQLParserTYPE_SYMBOL = 276 + GoogleSQLParserUNDROP_SYMBOL = 277 + GoogleSQLParserUNIQUE_SYMBOL = 278 + GoogleSQLParserUNKNOWN_SYMBOL = 279 + GoogleSQLParserUNTIL_SYMBOL = 280 + GoogleSQLParserUPDATE_SYMBOL = 281 + GoogleSQLParserVALUES_SYMBOL = 282 + GoogleSQLParserVECTOR_SYMBOL = 283 + GoogleSQLParserVIEW_SYMBOL = 284 + GoogleSQLParserVIEWS_SYMBOL = 285 + GoogleSQLParserVOLATILE_SYMBOL = 286 + GoogleSQLParserWEIGHT_SYMBOL = 287 + GoogleSQLParserWHILE_SYMBOL = 288 + GoogleSQLParserWRITE_SYMBOL = 289 + GoogleSQLParserZONE_SYMBOL = 290 + GoogleSQLParserDESCRIPTOR_SYMBOL = 291 + GoogleSQLParserINTERLEAVE_SYMBOL = 292 + GoogleSQLParserNULL_FILTERED_SYMBOL = 293 + GoogleSQLParserPARENT_SYMBOL = 294 + GoogleSQLParserNEW_SYMBOL = 295 + GoogleSQLParserEND_SYMBOL = 296 + GoogleSQLParserCASE_SYMBOL = 297 + GoogleSQLParserWHEN_SYMBOL = 298 + GoogleSQLParserTHEN_SYMBOL = 299 + GoogleSQLParserELSE_SYMBOL = 300 + GoogleSQLParserCAST_SYMBOL = 301 + GoogleSQLParserEXTRACT_SYMBOL = 302 + GoogleSQLParserCOLLATE_SYMBOL = 303 + GoogleSQLParserIF_SYMBOL = 304 + GoogleSQLParserGROUPING_SYMBOL = 305 + GoogleSQLParserHAVING_SYMBOL = 306 + GoogleSQLParserGROUP_SYMBOL = 307 + GoogleSQLParserROLLUP_SYMBOL = 308 + GoogleSQLParserCUBE_SYMBOL = 309 + GoogleSQLParserHASH_SYMBOL = 310 + GoogleSQLParserPROTO_SYMBOL = 311 + GoogleSQLParserPARTITION_SYMBOL = 312 + GoogleSQLParserIGNORE_SYMBOL = 313 + GoogleSQLParserRESPECT_SYMBOL = 314 + GoogleSQLParserROWS_SYMBOL = 315 + GoogleSQLParserOVER_SYMBOL = 316 + GoogleSQLParserBETWEEN_SYMBOL = 317 + GoogleSQLParserUNBOUNDED_SYMBOL = 318 + GoogleSQLParserCURRENT_SYMBOL = 319 + GoogleSQLParserPRECEDING_SYMBOL = 320 + GoogleSQLParserFOLLOWING_SYMBOL = 321 + GoogleSQLParserNATURAL_SYMBOL = 322 + GoogleSQLParserQUALIFY_SYMBOL = 323 + GoogleSQLParserDEFAULT_SYMBOL = 324 + GoogleSQLParserSLASH_SYMBOL = 325 + GoogleSQLParserMATCH_RECOGNIZE_SYMBOL = 326 + GoogleSQLParserDEFINE_SYMBOL = 327 + GoogleSQLParserLOOKUP_SYMBOL = 328 + GoogleSQLParserWHERE_SYMBOL = 329 + GoogleSQLParserWINDOW_SYMBOL = 330 + GoogleSQLParserTO_SYMBOL = 331 + GoogleSQLParserEXISTS_SYMBOL = 332 + GoogleSQLParserANY_SYMBOL = 333 + GoogleSQLParserSOME_SYMBOL = 334 + GoogleSQLParserLIKE_SYMBOL = 335 + GoogleSQLParserIS_SYMBOL = 336 + GoogleSQLParserNO_SYMBOL = 337 + GoogleSQLParserINTO_SYMBOL = 338 + GoogleSQLParserASSERT_ROWS_MODIFIED_SYMBOL = 339 + GoogleSQLParserCONFLICT_SYMBOL = 340 + GoogleSQLParserNOTHING_SYMBOL = 341 + GoogleSQLParserMERGE_SYMBOL = 342 + GoogleSQLParserCREATE_SYMBOL = 343 + GoogleSQLParserENUM_SYMBOL = 344 + GoogleSQLParserDESTINATION_SYMBOL = 345 + GoogleSQLParserPROPERTY_SYMBOL = 346 + GoogleSQLParserGRAPH_SYMBOL = 347 + GoogleSQLParserNODE_SYMBOL = 348 + GoogleSQLParserPROPERTIES_SYMBOL = 349 + GoogleSQLParserLABEL_SYMBOL = 350 + GoogleSQLParserEDGE_SYMBOL = 351 + GoogleSQLParserNEXT_SYMBOL = 352 + GoogleSQLParserASCENDING_SYMBOL = 353 + GoogleSQLParserDESCENDING_SYMBOL = 354 + GoogleSQLParserSKIP_SYMBOL = 355 + GoogleSQLParserSHORTEST_SYMBOL = 356 + GoogleSQLParserPATH_SYMBOL = 357 + GoogleSQLParserPATHS_SYMBOL = 358 + GoogleSQLParserWALK_SYMBOL = 359 + GoogleSQLParserTRAIL_SYMBOL = 360 + GoogleSQLParserACYCLIC_SYMBOL = 361 + GoogleSQLParserOPTIONAL_SYMBOL = 362 + GoogleSQLParserLET_SYMBOL = 363 + GoogleSQLParserIDENTIFIER = 364 + GoogleSQLParserUNCLOSED_ESCAPED_IDENTIFIER = 365 + GoogleSQLParserWHITESPACE = 366 + GoogleSQLParserCOMMENT = 367 +) + +// GoogleSQLParser rules. +const ( + GoogleSQLParserRULE_root = 0 + GoogleSQLParserRULE_stmts = 1 + GoogleSQLParserRULE_unterminated_sql_statement = 2 + GoogleSQLParserRULE_sql_statement_body = 3 + GoogleSQLParserRULE_gql_statement = 4 + GoogleSQLParserRULE_graph_operation_block = 5 + GoogleSQLParserRULE_graph_composite_query_block = 6 + GoogleSQLParserRULE_graph_composite_query_prefix = 7 + GoogleSQLParserRULE_graph_set_operation_metadata = 8 + GoogleSQLParserRULE_graph_linear_query_operation = 9 + GoogleSQLParserRULE_graph_linear_operator_list = 10 + GoogleSQLParserRULE_graph_linear_operator = 11 + GoogleSQLParserRULE_graph_sample_clause = 12 + GoogleSQLParserRULE_opt_graph_sample_clause_suffix = 13 + GoogleSQLParserRULE_graph_for_operator = 14 + GoogleSQLParserRULE_opt_with_offset_and_alias_with_required_as = 15 + GoogleSQLParserRULE_graph_with_operator = 16 + GoogleSQLParserRULE_graph_page_operator = 17 + GoogleSQLParserRULE_graph_order_by_operator = 18 + GoogleSQLParserRULE_graph_filter_operator = 19 + GoogleSQLParserRULE_graph_let_operator = 20 + GoogleSQLParserRULE_graph_let_variable_definition_list = 21 + GoogleSQLParserRULE_graph_let_variable_definition = 22 + GoogleSQLParserRULE_graph_optional_match_operator = 23 + GoogleSQLParserRULE_graph_match_operator = 24 + GoogleSQLParserRULE_graph_pattern = 25 + GoogleSQLParserRULE_graph_path_pattern_list = 26 + GoogleSQLParserRULE_graph_path_pattern = 27 + GoogleSQLParserRULE_graph_path_pattern_expr = 28 + GoogleSQLParserRULE_graph_path_factor = 29 + GoogleSQLParserRULE_graph_quantified_path_primary = 30 + GoogleSQLParserRULE_graph_path_primary = 31 + GoogleSQLParserRULE_graph_parenthesized_path_pattern = 32 + GoogleSQLParserRULE_graph_element_pattern = 33 + GoogleSQLParserRULE_graph_edge_pattern = 34 + GoogleSQLParserRULE_graph_node_pattern = 35 + GoogleSQLParserRULE_graph_element_pattern_filler = 36 + GoogleSQLParserRULE_graph_property_specification = 37 + GoogleSQLParserRULE_graph_property_name_and_value = 38 + GoogleSQLParserRULE_opt_is_label_expression = 39 + GoogleSQLParserRULE_label_expression = 40 + GoogleSQLParserRULE_label_primary = 41 + GoogleSQLParserRULE_parenthesized_label_expression = 42 + GoogleSQLParserRULE_opt_graph_element_identifier = 43 + GoogleSQLParserRULE_opt_graph_path_mode_prefix = 44 + GoogleSQLParserRULE_path_or_paths = 45 + GoogleSQLParserRULE_opt_graph_path_mode = 46 + GoogleSQLParserRULE_opt_graph_search_prefix = 47 + GoogleSQLParserRULE_opt_path_variable_assignment = 48 + GoogleSQLParserRULE_graph_identifier = 49 + GoogleSQLParserRULE_graph_return_operator = 50 + GoogleSQLParserRULE_graph_page_clause = 51 + GoogleSQLParserRULE_graph_order_by_clause = 52 + GoogleSQLParserRULE_graph_ordering_expression = 53 + GoogleSQLParserRULE_opt_graph_asc_or_desc = 54 + GoogleSQLParserRULE_graph_return_item_list = 55 + GoogleSQLParserRULE_graph_return_item = 56 + GoogleSQLParserRULE_undrop_statement = 57 + GoogleSQLParserRULE_module_statement = 58 + GoogleSQLParserRULE_import_statement = 59 + GoogleSQLParserRULE_opt_as_or_into_alias = 60 + GoogleSQLParserRULE_path_expression_or_string = 61 + GoogleSQLParserRULE_import_type = 62 + GoogleSQLParserRULE_call_statement = 63 + GoogleSQLParserRULE_drop_statement = 64 + GoogleSQLParserRULE_opt_drop_mode = 65 + GoogleSQLParserRULE_drop_all_row_access_policies_statement = 66 + GoogleSQLParserRULE_show_statement = 67 + GoogleSQLParserRULE_opt_like_string_literal = 68 + GoogleSQLParserRULE_show_target = 69 + GoogleSQLParserRULE_rename_statement = 70 + GoogleSQLParserRULE_revoke_statement = 71 + GoogleSQLParserRULE_grant_statement = 72 + GoogleSQLParserRULE_privileges = 73 + GoogleSQLParserRULE_export_metadata_statement = 74 + GoogleSQLParserRULE_export_model_statement = 75 + GoogleSQLParserRULE_export_data_statement = 76 + GoogleSQLParserRULE_export_data_no_query = 77 + GoogleSQLParserRULE_explain_statement = 78 + GoogleSQLParserRULE_execute_immediate = 79 + GoogleSQLParserRULE_opt_execute_into_clause = 80 + GoogleSQLParserRULE_opt_execute_using_clause = 81 + GoogleSQLParserRULE_execute_using_argument_list = 82 + GoogleSQLParserRULE_execute_using_argument = 83 + GoogleSQLParserRULE_describe_statement = 84 + GoogleSQLParserRULE_describe_info = 85 + GoogleSQLParserRULE_opt_from_path_expression = 86 + GoogleSQLParserRULE_describe_keyword = 87 + GoogleSQLParserRULE_define_table_statement = 88 + GoogleSQLParserRULE_create_entity_statement = 89 + GoogleSQLParserRULE_opt_generic_entity_body = 90 + GoogleSQLParserRULE_create_view_statement = 91 + GoogleSQLParserRULE_query_or_replica_source = 92 + GoogleSQLParserRULE_column_with_options_list = 93 + GoogleSQLParserRULE_column_with_options = 94 + GoogleSQLParserRULE_create_table_statement = 95 + GoogleSQLParserRULE_opt_ttl_clause = 96 + GoogleSQLParserRULE_opt_copy_table = 97 + GoogleSQLParserRULE_copy_data_source = 98 + GoogleSQLParserRULE_opt_clone_table = 99 + GoogleSQLParserRULE_opt_spanner_table_options = 100 + GoogleSQLParserRULE_opt_spanner_interleave_in_parent_clause = 101 + GoogleSQLParserRULE_spanner_primary_key = 102 + GoogleSQLParserRULE_create_table_function_statement = 103 + GoogleSQLParserRULE_opt_as_query_or_string = 104 + GoogleSQLParserRULE_unordered_language_options = 105 + GoogleSQLParserRULE_opt_function_parameters = 106 + GoogleSQLParserRULE_create_snapshot_statement = 107 + GoogleSQLParserRULE_create_external_schema_statement = 108 + GoogleSQLParserRULE_create_schema_statement = 109 + GoogleSQLParserRULE_create_property_graph_statement = 110 + GoogleSQLParserRULE_opt_edge_table_clause = 111 + GoogleSQLParserRULE_element_table_list = 112 + GoogleSQLParserRULE_element_table_definition = 113 + GoogleSQLParserRULE_opt_label_and_properties_clause = 114 + GoogleSQLParserRULE_label_and_properties_list = 115 + GoogleSQLParserRULE_label_and_properties = 116 + GoogleSQLParserRULE_properties_clause = 117 + GoogleSQLParserRULE_derived_property_list = 118 + GoogleSQLParserRULE_derived_property = 119 + GoogleSQLParserRULE_opt_except_column_list = 120 + GoogleSQLParserRULE_properties_all_columns = 121 + GoogleSQLParserRULE_opt_dest_node_table_clause = 122 + GoogleSQLParserRULE_opt_source_node_table_clause = 123 + GoogleSQLParserRULE_opt_key_clause = 124 + GoogleSQLParserRULE_create_model_statement = 125 + GoogleSQLParserRULE_opt_input_output_clause = 126 + GoogleSQLParserRULE_opt_transform_clause = 127 + GoogleSQLParserRULE_opt_as_query_or_aliased_query_list = 128 + GoogleSQLParserRULE_aliased_query_list = 129 + GoogleSQLParserRULE_as_query = 130 + GoogleSQLParserRULE_create_external_table_function_statement = 131 + GoogleSQLParserRULE_create_external_table_statement = 132 + GoogleSQLParserRULE_opt_default_collate_clause = 133 + GoogleSQLParserRULE_opt_like_path_expression = 134 + GoogleSQLParserRULE_create_row_access_policy_statement = 135 + GoogleSQLParserRULE_filter_using_clause = 136 + GoogleSQLParserRULE_create_row_access_policy_grant_to_clause = 137 + GoogleSQLParserRULE_create_privilege_restriction_statement = 138 + GoogleSQLParserRULE_restrict_to_clause = 139 + GoogleSQLParserRULE_possibly_empty_grantee_list = 140 + GoogleSQLParserRULE_create_index_statement = 141 + GoogleSQLParserRULE_opt_create_index_statement_suffix = 142 + GoogleSQLParserRULE_spanner_index_interleave_clause = 143 + GoogleSQLParserRULE_index_storing_list = 144 + GoogleSQLParserRULE_index_storing_expression_list = 145 + GoogleSQLParserRULE_index_order_by_and_options = 146 + GoogleSQLParserRULE_index_all_columns = 147 + GoogleSQLParserRULE_opt_with_column_options = 148 + GoogleSQLParserRULE_all_column_column_options = 149 + GoogleSQLParserRULE_column_ordering_and_options_expr = 150 + GoogleSQLParserRULE_index_unnest_expression_list = 151 + GoogleSQLParserRULE_unnest_expression_with_opt_alias_and_offset = 152 + GoogleSQLParserRULE_on_path_expression = 153 + GoogleSQLParserRULE_index_type = 154 + GoogleSQLParserRULE_opt_spanner_null_filtered = 155 + GoogleSQLParserRULE_create_procedure_statement = 156 + GoogleSQLParserRULE_begin_end_block_or_language_as_code = 157 + GoogleSQLParserRULE_begin_end_block = 158 + GoogleSQLParserRULE_opt_exception_handler = 159 + GoogleSQLParserRULE_statement_list = 160 + GoogleSQLParserRULE_unterminated_non_empty_statement_list = 161 + GoogleSQLParserRULE_unterminated_statement = 162 + GoogleSQLParserRULE_unterminated_script_statement = 163 + GoogleSQLParserRULE_label = 164 + GoogleSQLParserRULE_unterminated_unlabeled_script_statement = 165 + GoogleSQLParserRULE_for_in_statement = 166 + GoogleSQLParserRULE_repeat_statement = 167 + GoogleSQLParserRULE_until_clause = 168 + GoogleSQLParserRULE_loop_statement = 169 + GoogleSQLParserRULE_while_statement = 170 + GoogleSQLParserRULE_raise_statement = 171 + GoogleSQLParserRULE_return_statement = 172 + GoogleSQLParserRULE_continue_statement = 173 + GoogleSQLParserRULE_variable_declaration = 174 + GoogleSQLParserRULE_break_statement = 175 + GoogleSQLParserRULE_case_statement = 176 + GoogleSQLParserRULE_when_then_clauses = 177 + GoogleSQLParserRULE_if_statement = 178 + GoogleSQLParserRULE_elseif_clauses = 179 + GoogleSQLParserRULE_opt_else = 180 + GoogleSQLParserRULE_opt_as_code = 181 + GoogleSQLParserRULE_opt_external_security_clause = 182 + GoogleSQLParserRULE_external_security_clause_kind = 183 + GoogleSQLParserRULE_procedure_parameters = 184 + GoogleSQLParserRULE_procedure_parameter = 185 + GoogleSQLParserRULE_procedure_parameter_termination = 186 + GoogleSQLParserRULE_opt_procedure_parameter_mode = 187 + GoogleSQLParserRULE_create_function_statement = 188 + GoogleSQLParserRULE_opt_determinism_level = 189 + GoogleSQLParserRULE_opt_sql_security_clause = 190 + GoogleSQLParserRULE_sql_security_clause_kind = 191 + GoogleSQLParserRULE_as_sql_function_body_or_string = 192 + GoogleSQLParserRULE_sql_function_body = 193 + GoogleSQLParserRULE_unordered_options_body = 194 + GoogleSQLParserRULE_opt_language_or_remote_with_connection = 195 + GoogleSQLParserRULE_language = 196 + GoogleSQLParserRULE_remote_with_connection_clause = 197 + GoogleSQLParserRULE_with_connection_clause = 198 + GoogleSQLParserRULE_opt_function_returns = 199 + GoogleSQLParserRULE_opt_returns = 200 + GoogleSQLParserRULE_function_declaration = 201 + GoogleSQLParserRULE_function_parameters = 202 + GoogleSQLParserRULE_function_parameter = 203 + GoogleSQLParserRULE_opt_not_aggregate = 204 + GoogleSQLParserRULE_opt_default_expression = 205 + GoogleSQLParserRULE_type_or_tvf_schema = 206 + GoogleSQLParserRULE_tvf_schema = 207 + GoogleSQLParserRULE_tvf_schema_column = 208 + GoogleSQLParserRULE_templated_parameter_type = 209 + GoogleSQLParserRULE_templated_parameter_kind = 210 + GoogleSQLParserRULE_opt_aggregate = 211 + GoogleSQLParserRULE_create_database_statement = 212 + GoogleSQLParserRULE_create_connection_statement = 213 + GoogleSQLParserRULE_create_constant_statement = 214 + GoogleSQLParserRULE_opt_or_replace = 215 + GoogleSQLParserRULE_opt_create_scope = 216 + GoogleSQLParserRULE_run_batch_statement = 217 + GoogleSQLParserRULE_abort_batch_statement = 218 + GoogleSQLParserRULE_start_batch_statement = 219 + GoogleSQLParserRULE_rollback_statement = 220 + GoogleSQLParserRULE_commit_statement = 221 + GoogleSQLParserRULE_set_statement = 222 + GoogleSQLParserRULE_identifier_list = 223 + GoogleSQLParserRULE_begin_statement = 224 + GoogleSQLParserRULE_begin_transaction_keywords = 225 + GoogleSQLParserRULE_transaction_mode_list = 226 + GoogleSQLParserRULE_transaction_mode = 227 + GoogleSQLParserRULE_truncate_statement = 228 + GoogleSQLParserRULE_merge_statement = 229 + GoogleSQLParserRULE_merge_source = 230 + GoogleSQLParserRULE_merge_when_clause = 231 + GoogleSQLParserRULE_merge_action = 232 + GoogleSQLParserRULE_merge_insert_value_list_or_source_row = 233 + GoogleSQLParserRULE_by_target = 234 + GoogleSQLParserRULE_opt_and_expression = 235 + GoogleSQLParserRULE_statement_level_hint = 236 + GoogleSQLParserRULE_query_statement = 237 + GoogleSQLParserRULE_dml_statement = 238 + GoogleSQLParserRULE_update_statement = 239 + GoogleSQLParserRULE_delete_statement = 240 + GoogleSQLParserRULE_insert_statement = 241 + GoogleSQLParserRULE_on_conflict_clause = 242 + GoogleSQLParserRULE_opt_where_expression = 243 + GoogleSQLParserRULE_opt_conflict_target = 244 + GoogleSQLParserRULE_update_item_list = 245 + GoogleSQLParserRULE_update_item = 246 + GoogleSQLParserRULE_update_set_value = 247 + GoogleSQLParserRULE_nested_dml_statement = 248 + GoogleSQLParserRULE_insert_values_list_or_table_clause = 249 + GoogleSQLParserRULE_table_clause_unreversed = 250 + GoogleSQLParserRULE_table_clause_no_keyword = 251 + GoogleSQLParserRULE_opt_returning_clause = 252 + GoogleSQLParserRULE_opt_assert_rows_modified = 253 + GoogleSQLParserRULE_insert_values_or_query = 254 + GoogleSQLParserRULE_insert_values_list = 255 + GoogleSQLParserRULE_insert_values_row = 256 + GoogleSQLParserRULE_expression_or_default = 257 + GoogleSQLParserRULE_insert_statement_prefix = 258 + GoogleSQLParserRULE_maybe_dashed_generalized_path_expression = 259 + GoogleSQLParserRULE_opt_into = 260 + GoogleSQLParserRULE_opt_or_ignore_replace_update = 261 + GoogleSQLParserRULE_alter_statement = 262 + GoogleSQLParserRULE_analyze_statement = 263 + GoogleSQLParserRULE_assert_statement = 264 + GoogleSQLParserRULE_aux_load_data_statement = 265 + GoogleSQLParserRULE_clone_data_statement = 266 + GoogleSQLParserRULE_clone_data_source_list = 267 + GoogleSQLParserRULE_clone_data_source = 268 + GoogleSQLParserRULE_opt_external_table_with_clauses = 269 + GoogleSQLParserRULE_with_partition_columns_clause = 270 + GoogleSQLParserRULE_aux_load_data_from_files_options_list = 271 + GoogleSQLParserRULE_cluster_by_clause_prefix_no_hint = 272 + GoogleSQLParserRULE_load_data_partitions_clause = 273 + GoogleSQLParserRULE_maybe_dashed_path_expression_with_scope = 274 + GoogleSQLParserRULE_table_element_list = 275 + GoogleSQLParserRULE_table_element = 276 + GoogleSQLParserRULE_table_constraint_definition = 277 + GoogleSQLParserRULE_append_or_overwrite = 278 + GoogleSQLParserRULE_opt_description = 279 + GoogleSQLParserRULE_table_and_column_info_list = 280 + GoogleSQLParserRULE_table_and_column_info = 281 + GoogleSQLParserRULE_row_access_policy_alter_action_list = 282 + GoogleSQLParserRULE_row_access_policy_alter_action = 283 + GoogleSQLParserRULE_grant_to_clause = 284 + GoogleSQLParserRULE_grantee_list = 285 + GoogleSQLParserRULE_privilege_list = 286 + GoogleSQLParserRULE_privilege = 287 + GoogleSQLParserRULE_path_expression_list_with_parens = 288 + GoogleSQLParserRULE_privilege_name = 289 + GoogleSQLParserRULE_generic_entity_type = 290 + GoogleSQLParserRULE_generic_entity_type_unchecked = 291 + GoogleSQLParserRULE_schema_object_kind = 292 + GoogleSQLParserRULE_alter_action_list = 293 + GoogleSQLParserRULE_alter_action = 294 + GoogleSQLParserRULE_spanner_set_on_delete_action = 295 + GoogleSQLParserRULE_spanner_alter_column_action = 296 + GoogleSQLParserRULE_spanner_generated_or_default = 297 + GoogleSQLParserRULE_generic_sub_entity_type = 298 + GoogleSQLParserRULE_sub_entity_type_identifier = 299 + GoogleSQLParserRULE_fill_using_expression = 300 + GoogleSQLParserRULE_column_position = 301 + GoogleSQLParserRULE_table_column_definition = 302 + GoogleSQLParserRULE_column_attributes = 303 + GoogleSQLParserRULE_column_attribute = 304 + GoogleSQLParserRULE_primary_key_column_attribute = 305 + GoogleSQLParserRULE_foreign_key_column_attribute = 306 + GoogleSQLParserRULE_hidden_column_attribute = 307 + GoogleSQLParserRULE_opt_constraint_identity = 308 + GoogleSQLParserRULE_table_column_schema = 309 + GoogleSQLParserRULE_opt_column_info = 310 + GoogleSQLParserRULE_invalid_generated_column = 311 + GoogleSQLParserRULE_invalid_default_column = 312 + GoogleSQLParserRULE_default_column_info = 313 + GoogleSQLParserRULE_generated_column_info = 314 + GoogleSQLParserRULE_identity_column_info = 315 + GoogleSQLParserRULE_opt_start_with = 316 + GoogleSQLParserRULE_opt_increment_by = 317 + GoogleSQLParserRULE_opt_maxvalue = 318 + GoogleSQLParserRULE_opt_minvalue = 319 + GoogleSQLParserRULE_opt_cycle = 320 + GoogleSQLParserRULE_signed_numeric_literal = 321 + GoogleSQLParserRULE_stored_mode = 322 + GoogleSQLParserRULE_generated_mode = 323 + GoogleSQLParserRULE_column_schema_inner = 324 + GoogleSQLParserRULE_raw_column_schema_inner = 325 + GoogleSQLParserRULE_range_column_schema_inner = 326 + GoogleSQLParserRULE_struct_column_schema_inner = 327 + GoogleSQLParserRULE_struct_column_field = 328 + GoogleSQLParserRULE_simple_column_schema_inner = 329 + GoogleSQLParserRULE_array_column_schema_inner = 330 + GoogleSQLParserRULE_field_schema = 331 + GoogleSQLParserRULE_opt_field_attributes = 332 + GoogleSQLParserRULE_not_null_column_attribute = 333 + GoogleSQLParserRULE_primary_key_or_table_constraint_spec = 334 + GoogleSQLParserRULE_opt_if_not_exists = 335 + GoogleSQLParserRULE_primary_key_spec = 336 + GoogleSQLParserRULE_primary_key_element_list = 337 + GoogleSQLParserRULE_primary_key_element = 338 + GoogleSQLParserRULE_table_constraint_spec = 339 + GoogleSQLParserRULE_foreign_key_reference = 340 + GoogleSQLParserRULE_opt_foreign_key_action = 341 + GoogleSQLParserRULE_foreign_key_on_update = 342 + GoogleSQLParserRULE_foreign_key_on_delete = 343 + GoogleSQLParserRULE_foreign_key_action = 344 + GoogleSQLParserRULE_opt_foreign_key_match = 345 + GoogleSQLParserRULE_foreign_key_match_mode = 346 + GoogleSQLParserRULE_column_list = 347 + GoogleSQLParserRULE_opt_options_list = 348 + GoogleSQLParserRULE_constraint_enforcement = 349 + GoogleSQLParserRULE_generic_entity_body = 350 + GoogleSQLParserRULE_opt_if_exists = 351 + GoogleSQLParserRULE_table_or_table_function = 352 + GoogleSQLParserRULE_query = 353 + GoogleSQLParserRULE_query_without_pipe_operators = 354 + GoogleSQLParserRULE_bad_keyword_after_from_query = 355 + GoogleSQLParserRULE_bad_keyword_after_from_query_allows_parens = 356 + GoogleSQLParserRULE_with_clause_with_trailing_comma = 357 + GoogleSQLParserRULE_select_or_from_keyword = 358 + GoogleSQLParserRULE_query_primary_or_set_operation = 359 + GoogleSQLParserRULE_query_set_operation = 360 + GoogleSQLParserRULE_query_set_operation_prefix = 361 + GoogleSQLParserRULE_query_set_operation_item = 362 + GoogleSQLParserRULE_query_primary = 363 + GoogleSQLParserRULE_set_operation_metadata = 364 + GoogleSQLParserRULE_opt_column_match_suffix = 365 + GoogleSQLParserRULE_opt_strict = 366 + GoogleSQLParserRULE_all_or_distinct = 367 + GoogleSQLParserRULE_query_set_operation_type = 368 + GoogleSQLParserRULE_opt_corresponding_outer_mode = 369 + GoogleSQLParserRULE_opt_outer = 370 + GoogleSQLParserRULE_with_clause = 371 + GoogleSQLParserRULE_aliased_query = 372 + GoogleSQLParserRULE_opt_aliased_query_modifiers = 373 + GoogleSQLParserRULE_recursion_depth_modifier = 374 + GoogleSQLParserRULE_possibly_unbounded_int_literal_or_parameter = 375 + GoogleSQLParserRULE_int_literal_or_parameter = 376 + GoogleSQLParserRULE_order_by_clause = 377 + GoogleSQLParserRULE_order_by_clause_prefix = 378 + GoogleSQLParserRULE_ordering_expression = 379 + GoogleSQLParserRULE_select = 380 + GoogleSQLParserRULE_opt_clauses_following_from = 381 + GoogleSQLParserRULE_opt_clauses_following_where = 382 + GoogleSQLParserRULE_opt_clauses_following_group_by = 383 + GoogleSQLParserRULE_window_clause = 384 + GoogleSQLParserRULE_window_clause_prefix = 385 + GoogleSQLParserRULE_window_definition = 386 + GoogleSQLParserRULE_where_clause = 387 + GoogleSQLParserRULE_having_clause = 388 + GoogleSQLParserRULE_group_by_clause = 389 + GoogleSQLParserRULE_group_by_all = 390 + GoogleSQLParserRULE_select_clause = 391 + GoogleSQLParserRULE_opt_select_as_clause = 392 + GoogleSQLParserRULE_opt_select_with = 393 + GoogleSQLParserRULE_from_clause = 394 + GoogleSQLParserRULE_from_clause_contents = 395 + GoogleSQLParserRULE_from_clause_contents_suffix = 396 + GoogleSQLParserRULE_table_primary = 397 + GoogleSQLParserRULE_tvf_with_suffixes = 398 + GoogleSQLParserRULE_pivot_or_unpivot_clause_and_aliases = 399 + GoogleSQLParserRULE_as_alias = 400 + GoogleSQLParserRULE_sample_clause = 401 + GoogleSQLParserRULE_opt_sample_clause_suffix = 402 + GoogleSQLParserRULE_repeatable_clause = 403 + GoogleSQLParserRULE_possibly_cast_int_literal_or_parameter = 404 + GoogleSQLParserRULE_cast_int_literal_or_parameter = 405 + GoogleSQLParserRULE_sample_size = 406 + GoogleSQLParserRULE_sample_size_value = 407 + GoogleSQLParserRULE_sample_size_unit = 408 + GoogleSQLParserRULE_partition_by_clause_prefix_no_hint = 409 + GoogleSQLParserRULE_match_recognize_clause = 410 + GoogleSQLParserRULE_row_pattern_expr = 411 + GoogleSQLParserRULE_row_pattern_concatenation = 412 + GoogleSQLParserRULE_row_pattern_factor = 413 + GoogleSQLParserRULE_select_list_prefix_with_as_aliases = 414 + GoogleSQLParserRULE_select_column_expr_with_as_alias = 415 + GoogleSQLParserRULE_table_subquery = 416 + GoogleSQLParserRULE_join = 417 + GoogleSQLParserRULE_join_item = 418 + GoogleSQLParserRULE_on_or_using_clause_list = 419 + GoogleSQLParserRULE_on_or_using_clause = 420 + GoogleSQLParserRULE_using_clause = 421 + GoogleSQLParserRULE_join_hint = 422 + GoogleSQLParserRULE_table_path_expression = 423 + GoogleSQLParserRULE_opt_at_system_time = 424 + GoogleSQLParserRULE_opt_with_offset_and_alias = 425 + GoogleSQLParserRULE_opt_pivot_or_unpivot_clause_and_alias = 426 + GoogleSQLParserRULE_table_path_expression_base = 427 + GoogleSQLParserRULE_maybe_slashed_or_dashed_path_expression = 428 + GoogleSQLParserRULE_maybe_dashed_path_expression = 429 + GoogleSQLParserRULE_dashed_path_expression = 430 + GoogleSQLParserRULE_dashed_identifier = 431 + GoogleSQLParserRULE_slashed_identifier = 432 + GoogleSQLParserRULE_identifier_or_integer = 433 + GoogleSQLParserRULE_slashed_identifier_separator = 434 + GoogleSQLParserRULE_slashed_path_expression = 435 + GoogleSQLParserRULE_unnest_expression = 436 + GoogleSQLParserRULE_unnest_expression_prefix = 437 + GoogleSQLParserRULE_opt_array_zip_mode = 438 + GoogleSQLParserRULE_expression_with_opt_alias = 439 + GoogleSQLParserRULE_tvf_prefix = 440 + GoogleSQLParserRULE_tvf_argument = 441 + GoogleSQLParserRULE_connection_clause = 442 + GoogleSQLParserRULE_path_expression_or_default = 443 + GoogleSQLParserRULE_descriptor_argument = 444 + GoogleSQLParserRULE_descriptor_column_list = 445 + GoogleSQLParserRULE_descriptor_column = 446 + GoogleSQLParserRULE_table_clause = 447 + GoogleSQLParserRULE_model_clause = 448 + GoogleSQLParserRULE_qualify_clause_nonreserved = 449 + GoogleSQLParserRULE_unpivot_clause = 450 + GoogleSQLParserRULE_unpivot_in_item_list = 451 + GoogleSQLParserRULE_unpivot_in_item_list_prefix = 452 + GoogleSQLParserRULE_unpivot_in_item = 453 + GoogleSQLParserRULE_opt_as_string_or_integer = 454 + GoogleSQLParserRULE_path_expression_list_with_opt_parens = 455 + GoogleSQLParserRULE_path_expression_list = 456 + GoogleSQLParserRULE_unpivot_nulls_filter = 457 + GoogleSQLParserRULE_pivot_clause = 458 + GoogleSQLParserRULE_pivot_expression_list = 459 + GoogleSQLParserRULE_pivot_expression = 460 + GoogleSQLParserRULE_pivot_value_list = 461 + GoogleSQLParserRULE_pivot_value = 462 + GoogleSQLParserRULE_tvf_prefix_no_args = 463 + GoogleSQLParserRULE_join_type = 464 + GoogleSQLParserRULE_opt_natural = 465 + GoogleSQLParserRULE_on_clause = 466 + GoogleSQLParserRULE_select_list = 467 + GoogleSQLParserRULE_select_list_item = 468 + GoogleSQLParserRULE_select_column_star = 469 + GoogleSQLParserRULE_select_column_expr = 470 + GoogleSQLParserRULE_select_column_dot_star = 471 + GoogleSQLParserRULE_star_modifiers = 472 + GoogleSQLParserRULE_star_except_list = 473 + GoogleSQLParserRULE_star_replace_list = 474 + GoogleSQLParserRULE_star_replace_item = 475 + GoogleSQLParserRULE_expression = 476 + GoogleSQLParserRULE_expression_higher_prec_than_and = 477 + GoogleSQLParserRULE_expression_maybe_parenthesized_not_a_query = 478 + GoogleSQLParserRULE_parenthesized_in_rhs = 479 + GoogleSQLParserRULE_unary_operator = 480 + GoogleSQLParserRULE_comparative_operator = 481 + GoogleSQLParserRULE_shift_operator = 482 + GoogleSQLParserRULE_additive_operator = 483 + GoogleSQLParserRULE_multiplicative_operator = 484 + GoogleSQLParserRULE_is_operator = 485 + GoogleSQLParserRULE_between_operator = 486 + GoogleSQLParserRULE_in_operator = 487 + GoogleSQLParserRULE_distinct_operator = 488 + GoogleSQLParserRULE_parenthesized_query = 489 + GoogleSQLParserRULE_parenthesized_expression_not_a_query = 490 + GoogleSQLParserRULE_parenthesized_anysomeall_list_in_rhs = 491 + GoogleSQLParserRULE_and_expression = 492 + GoogleSQLParserRULE_in_list_two_or_more_prefix = 493 + GoogleSQLParserRULE_any_some_all = 494 + GoogleSQLParserRULE_like_operator = 495 + GoogleSQLParserRULE_expression_subquery_with_keyword = 496 + GoogleSQLParserRULE_struct_constructor = 497 + GoogleSQLParserRULE_struct_constructor_prefix_with_keyword = 498 + GoogleSQLParserRULE_struct_constructor_arg = 499 + GoogleSQLParserRULE_struct_constructor_prefix_without_keyword = 500 + GoogleSQLParserRULE_struct_constructor_prefix_with_keyword_no_arg = 501 + GoogleSQLParserRULE_interval_expression = 502 + GoogleSQLParserRULE_function_call_expression_with_clauses = 503 + GoogleSQLParserRULE_function_call_expression_with_clauses_suffix = 504 + GoogleSQLParserRULE_over_clause = 505 + GoogleSQLParserRULE_window_specification = 506 + GoogleSQLParserRULE_opt_window_frame_clause = 507 + GoogleSQLParserRULE_window_frame_bound = 508 + GoogleSQLParserRULE_preceding_or_following = 509 + GoogleSQLParserRULE_frame_unit = 510 + GoogleSQLParserRULE_partition_by_clause = 511 + GoogleSQLParserRULE_partition_by_clause_prefix = 512 + GoogleSQLParserRULE_with_group_rows = 513 + GoogleSQLParserRULE_with_report_modifier = 514 + GoogleSQLParserRULE_clamped_between_modifier = 515 + GoogleSQLParserRULE_with_report_format = 516 + GoogleSQLParserRULE_options_list = 517 + GoogleSQLParserRULE_options_list_prefix = 518 + GoogleSQLParserRULE_options_entry = 519 + GoogleSQLParserRULE_expression_or_proto = 520 + GoogleSQLParserRULE_options_assignment_operator = 521 + GoogleSQLParserRULE_opt_null_handling_modifier = 522 + GoogleSQLParserRULE_function_call_argument = 523 + GoogleSQLParserRULE_sequence_arg = 524 + GoogleSQLParserRULE_named_argument = 525 + GoogleSQLParserRULE_lambda_argument = 526 + GoogleSQLParserRULE_lambda_argument_list = 527 + GoogleSQLParserRULE_limit_offset_clause = 528 + GoogleSQLParserRULE_opt_having_or_group_by_modifier = 529 + GoogleSQLParserRULE_group_by_clause_prefix = 530 + GoogleSQLParserRULE_group_by_preamble = 531 + GoogleSQLParserRULE_opt_and_order = 532 + GoogleSQLParserRULE_hint = 533 + GoogleSQLParserRULE_hint_with_body = 534 + GoogleSQLParserRULE_hint_with_body_prefix = 535 + GoogleSQLParserRULE_hint_entry = 536 + GoogleSQLParserRULE_identifier_in_hints = 537 + GoogleSQLParserRULE_extra_identifier_in_hints_name = 538 + GoogleSQLParserRULE_grouping_item = 539 + GoogleSQLParserRULE_grouping_set_list = 540 + GoogleSQLParserRULE_grouping_set = 541 + GoogleSQLParserRULE_cube_list = 542 + GoogleSQLParserRULE_rollup_list = 543 + GoogleSQLParserRULE_opt_as_alias_with_required_as = 544 + GoogleSQLParserRULE_opt_grouping_item_order = 545 + GoogleSQLParserRULE_opt_selection_item_order = 546 + GoogleSQLParserRULE_asc_or_desc = 547 + GoogleSQLParserRULE_null_order = 548 + GoogleSQLParserRULE_function_name_from_keyword = 549 + GoogleSQLParserRULE_replace_fields_expression = 550 + GoogleSQLParserRULE_replace_fields_prefix = 551 + GoogleSQLParserRULE_replace_fields_arg = 552 + GoogleSQLParserRULE_generalized_path_expression = 553 + GoogleSQLParserRULE_generalized_extension_path = 554 + GoogleSQLParserRULE_with_expression = 555 + GoogleSQLParserRULE_with_expression_variable_prefix = 556 + GoogleSQLParserRULE_with_expression_variable = 557 + GoogleSQLParserRULE_extract_expression = 558 + GoogleSQLParserRULE_extract_expression_base = 559 + GoogleSQLParserRULE_opt_format = 560 + GoogleSQLParserRULE_opt_at_time_zone = 561 + GoogleSQLParserRULE_cast_expression = 562 + GoogleSQLParserRULE_case_expression = 563 + GoogleSQLParserRULE_case_expression_prefix = 564 + GoogleSQLParserRULE_case_value_expression_prefix = 565 + GoogleSQLParserRULE_case_no_value_expression_prefix = 566 + GoogleSQLParserRULE_struct_braced_constructor = 567 + GoogleSQLParserRULE_braced_new_constructor = 568 + GoogleSQLParserRULE_braced_constructor = 569 + GoogleSQLParserRULE_braced_constructor_start = 570 + GoogleSQLParserRULE_braced_constructor_prefix = 571 + GoogleSQLParserRULE_braced_constructor_field = 572 + GoogleSQLParserRULE_braced_constructor_lhs = 573 + GoogleSQLParserRULE_braced_constructor_field_value = 574 + GoogleSQLParserRULE_braced_constructor_extension = 575 + GoogleSQLParserRULE_new_constructor = 576 + GoogleSQLParserRULE_new_constructor_prefix = 577 + GoogleSQLParserRULE_new_constructor_prefix_no_arg = 578 + GoogleSQLParserRULE_new_constructor_arg = 579 + GoogleSQLParserRULE_array_constructor = 580 + GoogleSQLParserRULE_array_constructor_prefix = 581 + GoogleSQLParserRULE_array_constructor_prefix_no_expressions = 582 + GoogleSQLParserRULE_range_literal = 583 + GoogleSQLParserRULE_range_type = 584 + GoogleSQLParserRULE_type = 585 + GoogleSQLParserRULE_collate_clause = 586 + GoogleSQLParserRULE_string_literal_or_parameter = 587 + GoogleSQLParserRULE_system_variable_expression = 588 + GoogleSQLParserRULE_parameter_expression = 589 + GoogleSQLParserRULE_named_parameter_expression = 590 + GoogleSQLParserRULE_opt_type_parameters = 591 + GoogleSQLParserRULE_type_parameters_prefix = 592 + GoogleSQLParserRULE_type_parameter = 593 + GoogleSQLParserRULE_raw_type = 594 + GoogleSQLParserRULE_map_type = 595 + GoogleSQLParserRULE_function_type = 596 + GoogleSQLParserRULE_function_type_prefix = 597 + GoogleSQLParserRULE_type_name = 598 + GoogleSQLParserRULE_path_expression = 599 + GoogleSQLParserRULE_identifier = 600 + GoogleSQLParserRULE_keyword_as_identifier = 601 + GoogleSQLParserRULE_common_keyword_as_identifier = 602 + GoogleSQLParserRULE_token_identifier = 603 + GoogleSQLParserRULE_struct_type = 604 + GoogleSQLParserRULE_struct_type_prefix = 605 + GoogleSQLParserRULE_struct_field = 606 + GoogleSQLParserRULE_array_type = 607 + GoogleSQLParserRULE_template_type_open = 608 + GoogleSQLParserRULE_template_type_close = 609 + GoogleSQLParserRULE_date_or_time_literal = 610 + GoogleSQLParserRULE_date_or_time_literal_kind = 611 + GoogleSQLParserRULE_floating_point_literal = 612 + GoogleSQLParserRULE_json_literal = 613 + GoogleSQLParserRULE_bignumeric_literal = 614 + GoogleSQLParserRULE_bignumeric_literal_prefix = 615 + GoogleSQLParserRULE_numeric_literal = 616 + GoogleSQLParserRULE_numeric_literal_prefix = 617 + GoogleSQLParserRULE_integer_literal = 618 + GoogleSQLParserRULE_bytes_literal = 619 + GoogleSQLParserRULE_null_literal = 620 + GoogleSQLParserRULE_boolean_literal = 621 + GoogleSQLParserRULE_string_literal = 622 + GoogleSQLParserRULE_string_literal_component = 623 + GoogleSQLParserRULE_bytes_literal_component = 624 +) + +// IRootContext is an interface to support dynamic dispatch. +type IRootContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Stmts() IStmtsContext + EOF() antlr.TerminalNode + + // IsRootContext differentiates from other interfaces. + IsRootContext() +} + +type RootContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRootContext() *RootContext { + var p = new(RootContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_root + return p +} + +func InitEmptyRootContext(p *RootContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_root +} + +func (*RootContext) IsRootContext() {} + +func NewRootContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RootContext { + var p = new(RootContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_root + + return p +} + +func (s *RootContext) GetParser() antlr.Parser { return s.parser } + +func (s *RootContext) Stmts() IStmtsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmtsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmtsContext) +} + +func (s *RootContext) EOF() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEOF, 0) +} + +func (s *RootContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RootContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RootContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterRoot(s) + } +} + +func (s *RootContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitRoot(s) + } +} + +func (s *RootContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitRoot(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Root() (localctx IRootContext) { + localctx = NewRootContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 0, GoogleSQLParserRULE_root) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1250) + p.Stmts() + } + { + p.SetState(1251) + p.Match(GoogleSQLParserEOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmtsContext is an interface to support dynamic dispatch. +type IStmtsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllUnterminated_sql_statement() []IUnterminated_sql_statementContext + Unterminated_sql_statement(i int) IUnterminated_sql_statementContext + AllSEMI_SYMBOL() []antlr.TerminalNode + SEMI_SYMBOL(i int) antlr.TerminalNode + + // IsStmtsContext differentiates from other interfaces. + IsStmtsContext() +} + +type StmtsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmtsContext() *StmtsContext { + var p = new(StmtsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_stmts + return p +} + +func InitEmptyStmtsContext(p *StmtsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_stmts +} + +func (*StmtsContext) IsStmtsContext() {} + +func NewStmtsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StmtsContext { + var p = new(StmtsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_stmts + + return p +} + +func (s *StmtsContext) GetParser() antlr.Parser { return s.parser } + +func (s *StmtsContext) AllUnterminated_sql_statement() []IUnterminated_sql_statementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUnterminated_sql_statementContext); ok { + len++ + } + } + + tst := make([]IUnterminated_sql_statementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUnterminated_sql_statementContext); ok { + tst[i] = t.(IUnterminated_sql_statementContext) + i++ + } + } + + return tst +} + +func (s *StmtsContext) Unterminated_sql_statement(i int) IUnterminated_sql_statementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnterminated_sql_statementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUnterminated_sql_statementContext) +} + +func (s *StmtsContext) AllSEMI_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserSEMI_SYMBOL) +} + +func (s *StmtsContext) SEMI_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSEMI_SYMBOL, i) +} + +func (s *StmtsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StmtsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StmtsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterStmts(s) + } +} + +func (s *StmtsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitStmts(s) + } +} + +func (s *StmtsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitStmts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Stmts() (localctx IStmtsContext) { + localctx = NewStmtsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2, GoogleSQLParserRULE_stmts) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1253) + p.Unterminated_sql_statement() + } + p.SetState(1258) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 0, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1254) + p.Match(GoogleSQLParserSEMI_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1255) + p.Unterminated_sql_statement() + } + + } + p.SetState(1260) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 0, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(1262) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserSEMI_SYMBOL { + { + p.SetState(1261) + p.Match(GoogleSQLParserSEMI_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnterminated_sql_statementContext is an interface to support dynamic dispatch. +type IUnterminated_sql_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Sql_statement_body() ISql_statement_bodyContext + Statement_level_hint() IStatement_level_hintContext + DEFINE_SYMBOL() antlr.TerminalNode + MACRO_SYMBOL() antlr.TerminalNode + + // IsUnterminated_sql_statementContext differentiates from other interfaces. + IsUnterminated_sql_statementContext() +} + +type Unterminated_sql_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnterminated_sql_statementContext() *Unterminated_sql_statementContext { + var p = new(Unterminated_sql_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unterminated_sql_statement + return p +} + +func InitEmptyUnterminated_sql_statementContext(p *Unterminated_sql_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unterminated_sql_statement +} + +func (*Unterminated_sql_statementContext) IsUnterminated_sql_statementContext() {} + +func NewUnterminated_sql_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unterminated_sql_statementContext { + var p = new(Unterminated_sql_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_unterminated_sql_statement + + return p +} + +func (s *Unterminated_sql_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unterminated_sql_statementContext) Sql_statement_body() ISql_statement_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_statement_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_statement_bodyContext) +} + +func (s *Unterminated_sql_statementContext) Statement_level_hint() IStatement_level_hintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatement_level_hintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatement_level_hintContext) +} + +func (s *Unterminated_sql_statementContext) DEFINE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDEFINE_SYMBOL, 0) +} + +func (s *Unterminated_sql_statementContext) MACRO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMACRO_SYMBOL, 0) +} + +func (s *Unterminated_sql_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unterminated_sql_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unterminated_sql_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterUnterminated_sql_statement(s) + } +} + +func (s *Unterminated_sql_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitUnterminated_sql_statement(s) + } +} + +func (s *Unterminated_sql_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitUnterminated_sql_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Unterminated_sql_statement() (localctx IUnterminated_sql_statementContext) { + localctx = NewUnterminated_sql_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 4, GoogleSQLParserRULE_unterminated_sql_statement) + var _la int + + p.SetState(1276) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 3, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(1265) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(1264) + p.Statement_level_hint() + } + + } + { + p.SetState(1267) + p.Sql_statement_body() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1268) + p.Match(GoogleSQLParserDEFINE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1269) + p.Match(GoogleSQLParserMACRO_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.NotifyErrorListeners("Syntax error: DEFINE MACRO statements cannot be composed from other expansions", nil, nil) + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1271) + p.Statement_level_hint() + } + { + p.SetState(1272) + p.Match(GoogleSQLParserDEFINE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1273) + p.Match(GoogleSQLParserMACRO_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.NotifyErrorListeners("Hints are not allowed on DEFINE MACRO statements", nil, nil) + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISql_statement_bodyContext is an interface to support dynamic dispatch. +type ISql_statement_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Query_statement() IQuery_statementContext + Alter_statement() IAlter_statementContext + Analyze_statement() IAnalyze_statementContext + Assert_statement() IAssert_statementContext + Aux_load_data_statement() IAux_load_data_statementContext + Clone_data_statement() IClone_data_statementContext + Dml_statement() IDml_statementContext + Merge_statement() IMerge_statementContext + Truncate_statement() ITruncate_statementContext + Begin_statement() IBegin_statementContext + Set_statement() ISet_statementContext + Commit_statement() ICommit_statementContext + Start_batch_statement() IStart_batch_statementContext + Run_batch_statement() IRun_batch_statementContext + Abort_batch_statement() IAbort_batch_statementContext + Create_constant_statement() ICreate_constant_statementContext + Create_connection_statement() ICreate_connection_statementContext + Create_database_statement() ICreate_database_statementContext + Create_function_statement() ICreate_function_statementContext + Create_procedure_statement() ICreate_procedure_statementContext + Create_index_statement() ICreate_index_statementContext + Create_privilege_restriction_statement() ICreate_privilege_restriction_statementContext + Create_row_access_policy_statement() ICreate_row_access_policy_statementContext + Create_external_table_statement() ICreate_external_table_statementContext + Create_external_table_function_statement() ICreate_external_table_function_statementContext + Create_model_statement() ICreate_model_statementContext + Create_property_graph_statement() ICreate_property_graph_statementContext + Create_schema_statement() ICreate_schema_statementContext + Create_external_schema_statement() ICreate_external_schema_statementContext + Create_snapshot_statement() ICreate_snapshot_statementContext + Create_table_function_statement() ICreate_table_function_statementContext + Create_table_statement() ICreate_table_statementContext + Create_view_statement() ICreate_view_statementContext + Create_entity_statement() ICreate_entity_statementContext + Define_table_statement() IDefine_table_statementContext + Describe_statement() IDescribe_statementContext + Execute_immediate() IExecute_immediateContext + Explain_statement() IExplain_statementContext + Export_data_statement() IExport_data_statementContext + Export_model_statement() IExport_model_statementContext + Export_metadata_statement() IExport_metadata_statementContext + Gql_statement() IGql_statementContext + Grant_statement() IGrant_statementContext + Rename_statement() IRename_statementContext + Revoke_statement() IRevoke_statementContext + Rollback_statement() IRollback_statementContext + Show_statement() IShow_statementContext + Drop_all_row_access_policies_statement() IDrop_all_row_access_policies_statementContext + Drop_statement() IDrop_statementContext + Call_statement() ICall_statementContext + Import_statement() IImport_statementContext + Module_statement() IModule_statementContext + Undrop_statement() IUndrop_statementContext + + // IsSql_statement_bodyContext differentiates from other interfaces. + IsSql_statement_bodyContext() +} + +type Sql_statement_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySql_statement_bodyContext() *Sql_statement_bodyContext { + var p = new(Sql_statement_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_sql_statement_body + return p +} + +func InitEmptySql_statement_bodyContext(p *Sql_statement_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_sql_statement_body +} + +func (*Sql_statement_bodyContext) IsSql_statement_bodyContext() {} + +func NewSql_statement_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_statement_bodyContext { + var p = new(Sql_statement_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_sql_statement_body + + return p +} + +func (s *Sql_statement_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sql_statement_bodyContext) Query_statement() IQuery_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_statementContext) +} + +func (s *Sql_statement_bodyContext) Alter_statement() IAlter_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_statementContext) +} + +func (s *Sql_statement_bodyContext) Analyze_statement() IAnalyze_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnalyze_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnalyze_statementContext) +} + +func (s *Sql_statement_bodyContext) Assert_statement() IAssert_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssert_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssert_statementContext) +} + +func (s *Sql_statement_bodyContext) Aux_load_data_statement() IAux_load_data_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAux_load_data_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAux_load_data_statementContext) +} + +func (s *Sql_statement_bodyContext) Clone_data_statement() IClone_data_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClone_data_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClone_data_statementContext) +} + +func (s *Sql_statement_bodyContext) Dml_statement() IDml_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDml_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDml_statementContext) +} + +func (s *Sql_statement_bodyContext) Merge_statement() IMerge_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_statementContext) +} + +func (s *Sql_statement_bodyContext) Truncate_statement() ITruncate_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITruncate_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITruncate_statementContext) +} + +func (s *Sql_statement_bodyContext) Begin_statement() IBegin_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBegin_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBegin_statementContext) +} + +func (s *Sql_statement_bodyContext) Set_statement() ISet_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_statementContext) +} + +func (s *Sql_statement_bodyContext) Commit_statement() ICommit_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommit_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommit_statementContext) +} + +func (s *Sql_statement_bodyContext) Start_batch_statement() IStart_batch_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStart_batch_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStart_batch_statementContext) +} + +func (s *Sql_statement_bodyContext) Run_batch_statement() IRun_batch_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRun_batch_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRun_batch_statementContext) +} + +func (s *Sql_statement_bodyContext) Abort_batch_statement() IAbort_batch_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAbort_batch_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAbort_batch_statementContext) +} + +func (s *Sql_statement_bodyContext) Create_constant_statement() ICreate_constant_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_constant_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_constant_statementContext) +} + +func (s *Sql_statement_bodyContext) Create_connection_statement() ICreate_connection_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_connection_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_connection_statementContext) +} + +func (s *Sql_statement_bodyContext) Create_database_statement() ICreate_database_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_database_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_database_statementContext) +} + +func (s *Sql_statement_bodyContext) Create_function_statement() ICreate_function_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_function_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_function_statementContext) +} + +func (s *Sql_statement_bodyContext) Create_procedure_statement() ICreate_procedure_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_procedure_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_procedure_statementContext) +} + +func (s *Sql_statement_bodyContext) Create_index_statement() ICreate_index_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_index_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_index_statementContext) +} + +func (s *Sql_statement_bodyContext) Create_privilege_restriction_statement() ICreate_privilege_restriction_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_privilege_restriction_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_privilege_restriction_statementContext) +} + +func (s *Sql_statement_bodyContext) Create_row_access_policy_statement() ICreate_row_access_policy_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_row_access_policy_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_row_access_policy_statementContext) +} + +func (s *Sql_statement_bodyContext) Create_external_table_statement() ICreate_external_table_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_external_table_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_external_table_statementContext) +} + +func (s *Sql_statement_bodyContext) Create_external_table_function_statement() ICreate_external_table_function_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_external_table_function_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_external_table_function_statementContext) +} + +func (s *Sql_statement_bodyContext) Create_model_statement() ICreate_model_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_model_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_model_statementContext) +} + +func (s *Sql_statement_bodyContext) Create_property_graph_statement() ICreate_property_graph_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_property_graph_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_property_graph_statementContext) +} + +func (s *Sql_statement_bodyContext) Create_schema_statement() ICreate_schema_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_schema_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_schema_statementContext) +} + +func (s *Sql_statement_bodyContext) Create_external_schema_statement() ICreate_external_schema_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_external_schema_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_external_schema_statementContext) +} + +func (s *Sql_statement_bodyContext) Create_snapshot_statement() ICreate_snapshot_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_snapshot_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_snapshot_statementContext) +} + +func (s *Sql_statement_bodyContext) Create_table_function_statement() ICreate_table_function_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_table_function_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_table_function_statementContext) +} + +func (s *Sql_statement_bodyContext) Create_table_statement() ICreate_table_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_table_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_table_statementContext) +} + +func (s *Sql_statement_bodyContext) Create_view_statement() ICreate_view_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_view_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_view_statementContext) +} + +func (s *Sql_statement_bodyContext) Create_entity_statement() ICreate_entity_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_entity_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_entity_statementContext) +} + +func (s *Sql_statement_bodyContext) Define_table_statement() IDefine_table_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefine_table_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefine_table_statementContext) +} + +func (s *Sql_statement_bodyContext) Describe_statement() IDescribe_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_statementContext) +} + +func (s *Sql_statement_bodyContext) Execute_immediate() IExecute_immediateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_immediateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExecute_immediateContext) +} + +func (s *Sql_statement_bodyContext) Explain_statement() IExplain_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExplain_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExplain_statementContext) +} + +func (s *Sql_statement_bodyContext) Export_data_statement() IExport_data_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExport_data_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExport_data_statementContext) +} + +func (s *Sql_statement_bodyContext) Export_model_statement() IExport_model_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExport_model_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExport_model_statementContext) +} + +func (s *Sql_statement_bodyContext) Export_metadata_statement() IExport_metadata_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExport_metadata_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExport_metadata_statementContext) +} + +func (s *Sql_statement_bodyContext) Gql_statement() IGql_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGql_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGql_statementContext) +} + +func (s *Sql_statement_bodyContext) Grant_statement() IGrant_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_statementContext) +} + +func (s *Sql_statement_bodyContext) Rename_statement() IRename_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRename_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRename_statementContext) +} + +func (s *Sql_statement_bodyContext) Revoke_statement() IRevoke_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_statementContext) +} + +func (s *Sql_statement_bodyContext) Rollback_statement() IRollback_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollback_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRollback_statementContext) +} + +func (s *Sql_statement_bodyContext) Show_statement() IShow_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_statementContext) +} + +func (s *Sql_statement_bodyContext) Drop_all_row_access_policies_statement() IDrop_all_row_access_policies_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_all_row_access_policies_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_all_row_access_policies_statementContext) +} + +func (s *Sql_statement_bodyContext) Drop_statement() IDrop_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_statementContext) +} + +func (s *Sql_statement_bodyContext) Call_statement() ICall_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_statementContext) +} + +func (s *Sql_statement_bodyContext) Import_statement() IImport_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImport_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImport_statementContext) +} + +func (s *Sql_statement_bodyContext) Module_statement() IModule_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModule_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModule_statementContext) +} + +func (s *Sql_statement_bodyContext) Undrop_statement() IUndrop_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUndrop_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUndrop_statementContext) +} + +func (s *Sql_statement_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sql_statement_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sql_statement_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSql_statement_body(s) + } +} + +func (s *Sql_statement_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSql_statement_body(s) + } +} + +func (s *Sql_statement_bodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSql_statement_body(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Sql_statement_body() (localctx ISql_statement_bodyContext) { + localctx = NewSql_statement_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 6, GoogleSQLParserRULE_sql_statement_body) + p.SetState(1331) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 4, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1278) + p.Query_statement() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1279) + p.Alter_statement() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1280) + p.Analyze_statement() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1281) + p.Assert_statement() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1282) + p.Aux_load_data_statement() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(1283) + p.Clone_data_statement() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(1284) + p.Dml_statement() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(1285) + p.Merge_statement() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(1286) + p.Truncate_statement() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(1287) + p.Begin_statement() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(1288) + p.Set_statement() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(1289) + p.Commit_statement() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(1290) + p.Start_batch_statement() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(1291) + p.Run_batch_statement() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(1292) + p.Abort_batch_statement() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(1293) + p.Create_constant_statement() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(1294) + p.Create_connection_statement() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(1295) + p.Create_database_statement() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(1296) + p.Create_function_statement() + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(1297) + p.Create_procedure_statement() + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(1298) + p.Create_index_statement() + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(1299) + p.Create_privilege_restriction_statement() + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(1300) + p.Create_row_access_policy_statement() + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(1301) + p.Create_external_table_statement() + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(1302) + p.Create_external_table_function_statement() + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(1303) + p.Create_model_statement() + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(1304) + p.Create_property_graph_statement() + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(1305) + p.Create_schema_statement() + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(1306) + p.Create_external_schema_statement() + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(1307) + p.Create_snapshot_statement() + } + + case 31: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(1308) + p.Create_table_function_statement() + } + + case 32: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(1309) + p.Create_table_statement() + } + + case 33: + p.EnterOuterAlt(localctx, 33) + { + p.SetState(1310) + p.Create_view_statement() + } + + case 34: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(1311) + p.Create_entity_statement() + } + + case 35: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(1312) + p.Define_table_statement() + } + + case 36: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(1313) + p.Describe_statement() + } + + case 37: + p.EnterOuterAlt(localctx, 37) + { + p.SetState(1314) + p.Execute_immediate() + } + + case 38: + p.EnterOuterAlt(localctx, 38) + { + p.SetState(1315) + p.Explain_statement() + } + + case 39: + p.EnterOuterAlt(localctx, 39) + { + p.SetState(1316) + p.Export_data_statement() + } + + case 40: + p.EnterOuterAlt(localctx, 40) + { + p.SetState(1317) + p.Export_model_statement() + } + + case 41: + p.EnterOuterAlt(localctx, 41) + { + p.SetState(1318) + p.Export_metadata_statement() + } + + case 42: + p.EnterOuterAlt(localctx, 42) + { + p.SetState(1319) + p.Gql_statement() + } + + case 43: + p.EnterOuterAlt(localctx, 43) + { + p.SetState(1320) + p.Grant_statement() + } + + case 44: + p.EnterOuterAlt(localctx, 44) + { + p.SetState(1321) + p.Rename_statement() + } + + case 45: + p.EnterOuterAlt(localctx, 45) + { + p.SetState(1322) + p.Revoke_statement() + } + + case 46: + p.EnterOuterAlt(localctx, 46) + { + p.SetState(1323) + p.Rollback_statement() + } + + case 47: + p.EnterOuterAlt(localctx, 47) + { + p.SetState(1324) + p.Show_statement() + } + + case 48: + p.EnterOuterAlt(localctx, 48) + { + p.SetState(1325) + p.Drop_all_row_access_policies_statement() + } + + case 49: + p.EnterOuterAlt(localctx, 49) + { + p.SetState(1326) + p.Drop_statement() + } + + case 50: + p.EnterOuterAlt(localctx, 50) + { + p.SetState(1327) + p.Call_statement() + } + + case 51: + p.EnterOuterAlt(localctx, 51) + { + p.SetState(1328) + p.Import_statement() + } + + case 52: + p.EnterOuterAlt(localctx, 52) + { + p.SetState(1329) + p.Module_statement() + } + + case 53: + p.EnterOuterAlt(localctx, 53) + { + p.SetState(1330) + p.Undrop_statement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGql_statementContext is an interface to support dynamic dispatch. +type IGql_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRAPH_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + Graph_operation_block() IGraph_operation_blockContext + + // IsGql_statementContext differentiates from other interfaces. + IsGql_statementContext() +} + +type Gql_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGql_statementContext() *Gql_statementContext { + var p = new(Gql_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_gql_statement + return p +} + +func InitEmptyGql_statementContext(p *Gql_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_gql_statement +} + +func (*Gql_statementContext) IsGql_statementContext() {} + +func NewGql_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Gql_statementContext { + var p = new(Gql_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_gql_statement + + return p +} + +func (s *Gql_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Gql_statementContext) GRAPH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserGRAPH_SYMBOL, 0) +} + +func (s *Gql_statementContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Gql_statementContext) Graph_operation_block() IGraph_operation_blockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_operation_blockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_operation_blockContext) +} + +func (s *Gql_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Gql_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Gql_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGql_statement(s) + } +} + +func (s *Gql_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGql_statement(s) + } +} + +func (s *Gql_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGql_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Gql_statement() (localctx IGql_statementContext) { + localctx = NewGql_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 8, GoogleSQLParserRULE_gql_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1333) + p.Match(GoogleSQLParserGRAPH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1334) + p.Path_expression() + } + { + p.SetState(1335) + p.Graph_operation_block() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_operation_blockContext is an interface to support dynamic dispatch. +type IGraph_operation_blockContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllGraph_composite_query_block() []IGraph_composite_query_blockContext + Graph_composite_query_block(i int) IGraph_composite_query_blockContext + AllNEXT_SYMBOL() []antlr.TerminalNode + NEXT_SYMBOL(i int) antlr.TerminalNode + + // IsGraph_operation_blockContext differentiates from other interfaces. + IsGraph_operation_blockContext() +} + +type Graph_operation_blockContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_operation_blockContext() *Graph_operation_blockContext { + var p = new(Graph_operation_blockContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_operation_block + return p +} + +func InitEmptyGraph_operation_blockContext(p *Graph_operation_blockContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_operation_block +} + +func (*Graph_operation_blockContext) IsGraph_operation_blockContext() {} + +func NewGraph_operation_blockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_operation_blockContext { + var p = new(Graph_operation_blockContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_operation_block + + return p +} + +func (s *Graph_operation_blockContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_operation_blockContext) AllGraph_composite_query_block() []IGraph_composite_query_blockContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGraph_composite_query_blockContext); ok { + len++ + } + } + + tst := make([]IGraph_composite_query_blockContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGraph_composite_query_blockContext); ok { + tst[i] = t.(IGraph_composite_query_blockContext) + i++ + } + } + + return tst +} + +func (s *Graph_operation_blockContext) Graph_composite_query_block(i int) IGraph_composite_query_blockContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_composite_query_blockContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGraph_composite_query_blockContext) +} + +func (s *Graph_operation_blockContext) AllNEXT_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserNEXT_SYMBOL) +} + +func (s *Graph_operation_blockContext) NEXT_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNEXT_SYMBOL, i) +} + +func (s *Graph_operation_blockContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_operation_blockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_operation_blockContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_operation_block(s) + } +} + +func (s *Graph_operation_blockContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_operation_block(s) + } +} + +func (s *Graph_operation_blockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_operation_block(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_operation_block() (localctx IGraph_operation_blockContext) { + localctx = NewGraph_operation_blockContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 10, GoogleSQLParserRULE_graph_operation_block) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1337) + p.Graph_composite_query_block() + } + p.SetState(1342) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserNEXT_SYMBOL { + { + p.SetState(1338) + p.Match(GoogleSQLParserNEXT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1339) + p.Graph_composite_query_block() + } + + p.SetState(1344) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_composite_query_blockContext is an interface to support dynamic dispatch. +type IGraph_composite_query_blockContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Graph_linear_query_operation() IGraph_linear_query_operationContext + Graph_composite_query_prefix() IGraph_composite_query_prefixContext + + // IsGraph_composite_query_blockContext differentiates from other interfaces. + IsGraph_composite_query_blockContext() +} + +type Graph_composite_query_blockContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_composite_query_blockContext() *Graph_composite_query_blockContext { + var p = new(Graph_composite_query_blockContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_composite_query_block + return p +} + +func InitEmptyGraph_composite_query_blockContext(p *Graph_composite_query_blockContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_composite_query_block +} + +func (*Graph_composite_query_blockContext) IsGraph_composite_query_blockContext() {} + +func NewGraph_composite_query_blockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_composite_query_blockContext { + var p = new(Graph_composite_query_blockContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_composite_query_block + + return p +} + +func (s *Graph_composite_query_blockContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_composite_query_blockContext) Graph_linear_query_operation() IGraph_linear_query_operationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_linear_query_operationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_linear_query_operationContext) +} + +func (s *Graph_composite_query_blockContext) Graph_composite_query_prefix() IGraph_composite_query_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_composite_query_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_composite_query_prefixContext) +} + +func (s *Graph_composite_query_blockContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_composite_query_blockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_composite_query_blockContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_composite_query_block(s) + } +} + +func (s *Graph_composite_query_blockContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_composite_query_block(s) + } +} + +func (s *Graph_composite_query_blockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_composite_query_block(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_composite_query_block() (localctx IGraph_composite_query_blockContext) { + localctx = NewGraph_composite_query_blockContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 12, GoogleSQLParserRULE_graph_composite_query_block) + p.SetState(1347) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 6, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1345) + p.Graph_linear_query_operation() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1346) + p.Graph_composite_query_prefix() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_composite_query_prefixContext is an interface to support dynamic dispatch. +type IGraph_composite_query_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllGraph_linear_query_operation() []IGraph_linear_query_operationContext + Graph_linear_query_operation(i int) IGraph_linear_query_operationContext + AllGraph_set_operation_metadata() []IGraph_set_operation_metadataContext + Graph_set_operation_metadata(i int) IGraph_set_operation_metadataContext + + // IsGraph_composite_query_prefixContext differentiates from other interfaces. + IsGraph_composite_query_prefixContext() +} + +type Graph_composite_query_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_composite_query_prefixContext() *Graph_composite_query_prefixContext { + var p = new(Graph_composite_query_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_composite_query_prefix + return p +} + +func InitEmptyGraph_composite_query_prefixContext(p *Graph_composite_query_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_composite_query_prefix +} + +func (*Graph_composite_query_prefixContext) IsGraph_composite_query_prefixContext() {} + +func NewGraph_composite_query_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_composite_query_prefixContext { + var p = new(Graph_composite_query_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_composite_query_prefix + + return p +} + +func (s *Graph_composite_query_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_composite_query_prefixContext) AllGraph_linear_query_operation() []IGraph_linear_query_operationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGraph_linear_query_operationContext); ok { + len++ + } + } + + tst := make([]IGraph_linear_query_operationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGraph_linear_query_operationContext); ok { + tst[i] = t.(IGraph_linear_query_operationContext) + i++ + } + } + + return tst +} + +func (s *Graph_composite_query_prefixContext) Graph_linear_query_operation(i int) IGraph_linear_query_operationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_linear_query_operationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGraph_linear_query_operationContext) +} + +func (s *Graph_composite_query_prefixContext) AllGraph_set_operation_metadata() []IGraph_set_operation_metadataContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGraph_set_operation_metadataContext); ok { + len++ + } + } + + tst := make([]IGraph_set_operation_metadataContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGraph_set_operation_metadataContext); ok { + tst[i] = t.(IGraph_set_operation_metadataContext) + i++ + } + } + + return tst +} + +func (s *Graph_composite_query_prefixContext) Graph_set_operation_metadata(i int) IGraph_set_operation_metadataContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_set_operation_metadataContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGraph_set_operation_metadataContext) +} + +func (s *Graph_composite_query_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_composite_query_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_composite_query_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_composite_query_prefix(s) + } +} + +func (s *Graph_composite_query_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_composite_query_prefix(s) + } +} + +func (s *Graph_composite_query_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_composite_query_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_composite_query_prefix() (localctx IGraph_composite_query_prefixContext) { + localctx = NewGraph_composite_query_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 14, GoogleSQLParserRULE_graph_composite_query_prefix) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1349) + p.Graph_linear_query_operation() + } + { + p.SetState(1350) + p.Graph_set_operation_metadata() + } + { + p.SetState(1351) + p.Graph_linear_query_operation() + } + p.SetState(1357) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for (int64((_la-68)) & ^0x3f) == 0 && ((int64(1)<<(_la-68))&4294967553) != 0 { + { + p.SetState(1352) + p.Graph_set_operation_metadata() + } + { + p.SetState(1353) + p.Graph_linear_query_operation() + } + + p.SetState(1359) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_set_operation_metadataContext is an interface to support dynamic dispatch. +type IGraph_set_operation_metadataContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Query_set_operation_type() IQuery_set_operation_typeContext + All_or_distinct() IAll_or_distinctContext + + // IsGraph_set_operation_metadataContext differentiates from other interfaces. + IsGraph_set_operation_metadataContext() +} + +type Graph_set_operation_metadataContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_set_operation_metadataContext() *Graph_set_operation_metadataContext { + var p = new(Graph_set_operation_metadataContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_set_operation_metadata + return p +} + +func InitEmptyGraph_set_operation_metadataContext(p *Graph_set_operation_metadataContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_set_operation_metadata +} + +func (*Graph_set_operation_metadataContext) IsGraph_set_operation_metadataContext() {} + +func NewGraph_set_operation_metadataContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_set_operation_metadataContext { + var p = new(Graph_set_operation_metadataContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_set_operation_metadata + + return p +} + +func (s *Graph_set_operation_metadataContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_set_operation_metadataContext) Query_set_operation_type() IQuery_set_operation_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_set_operation_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_set_operation_typeContext) +} + +func (s *Graph_set_operation_metadataContext) All_or_distinct() IAll_or_distinctContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_or_distinctContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_or_distinctContext) +} + +func (s *Graph_set_operation_metadataContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_set_operation_metadataContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_set_operation_metadataContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_set_operation_metadata(s) + } +} + +func (s *Graph_set_operation_metadataContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_set_operation_metadata(s) + } +} + +func (s *Graph_set_operation_metadataContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_set_operation_metadata(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_set_operation_metadata() (localctx IGraph_set_operation_metadataContext) { + localctx = NewGraph_set_operation_metadataContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 16, GoogleSQLParserRULE_graph_set_operation_metadata) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1360) + p.Query_set_operation_type() + } + { + p.SetState(1361) + p.All_or_distinct() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_linear_query_operationContext is an interface to support dynamic dispatch. +type IGraph_linear_query_operationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Graph_return_operator() IGraph_return_operatorContext + Graph_linear_operator_list() IGraph_linear_operator_listContext + + // IsGraph_linear_query_operationContext differentiates from other interfaces. + IsGraph_linear_query_operationContext() +} + +type Graph_linear_query_operationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_linear_query_operationContext() *Graph_linear_query_operationContext { + var p = new(Graph_linear_query_operationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_linear_query_operation + return p +} + +func InitEmptyGraph_linear_query_operationContext(p *Graph_linear_query_operationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_linear_query_operation +} + +func (*Graph_linear_query_operationContext) IsGraph_linear_query_operationContext() {} + +func NewGraph_linear_query_operationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_linear_query_operationContext { + var p = new(Graph_linear_query_operationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_linear_query_operation + + return p +} + +func (s *Graph_linear_query_operationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_linear_query_operationContext) Graph_return_operator() IGraph_return_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_return_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_return_operatorContext) +} + +func (s *Graph_linear_query_operationContext) Graph_linear_operator_list() IGraph_linear_operator_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_linear_operator_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_linear_operator_listContext) +} + +func (s *Graph_linear_query_operationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_linear_query_operationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_linear_query_operationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_linear_query_operation(s) + } +} + +func (s *Graph_linear_query_operationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_linear_query_operation(s) + } +} + +func (s *Graph_linear_query_operationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_linear_query_operation(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_linear_query_operation() (localctx IGraph_linear_query_operationContext) { + localctx = NewGraph_linear_query_operationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 18, GoogleSQLParserRULE_graph_linear_query_operation) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(1364) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-70)) & ^0x3f) == 0 && ((int64(1)<<(_la-70))&17716814081) != 0) || _la == GoogleSQLParserFILTER_SYMBOL || _la == GoogleSQLParserMATCH_SYMBOL || ((int64((_la-355)) & ^0x3f) == 0 && ((int64(1)<<(_la-355))&385) != 0) { + { + p.SetState(1363) + p.Graph_linear_operator_list() + } + + } + { + p.SetState(1366) + p.Graph_return_operator() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_linear_operator_listContext is an interface to support dynamic dispatch. +type IGraph_linear_operator_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllGraph_linear_operator() []IGraph_linear_operatorContext + Graph_linear_operator(i int) IGraph_linear_operatorContext + + // IsGraph_linear_operator_listContext differentiates from other interfaces. + IsGraph_linear_operator_listContext() +} + +type Graph_linear_operator_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_linear_operator_listContext() *Graph_linear_operator_listContext { + var p = new(Graph_linear_operator_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_linear_operator_list + return p +} + +func InitEmptyGraph_linear_operator_listContext(p *Graph_linear_operator_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_linear_operator_list +} + +func (*Graph_linear_operator_listContext) IsGraph_linear_operator_listContext() {} + +func NewGraph_linear_operator_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_linear_operator_listContext { + var p = new(Graph_linear_operator_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_linear_operator_list + + return p +} + +func (s *Graph_linear_operator_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_linear_operator_listContext) AllGraph_linear_operator() []IGraph_linear_operatorContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGraph_linear_operatorContext); ok { + len++ + } + } + + tst := make([]IGraph_linear_operatorContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGraph_linear_operatorContext); ok { + tst[i] = t.(IGraph_linear_operatorContext) + i++ + } + } + + return tst +} + +func (s *Graph_linear_operator_listContext) Graph_linear_operator(i int) IGraph_linear_operatorContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_linear_operatorContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGraph_linear_operatorContext) +} + +func (s *Graph_linear_operator_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_linear_operator_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_linear_operator_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_linear_operator_list(s) + } +} + +func (s *Graph_linear_operator_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_linear_operator_list(s) + } +} + +func (s *Graph_linear_operator_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_linear_operator_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_linear_operator_list() (localctx IGraph_linear_operator_listContext) { + localctx = NewGraph_linear_operator_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 20, GoogleSQLParserRULE_graph_linear_operator_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(1369) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64((_la-70)) & ^0x3f) == 0 && ((int64(1)<<(_la-70))&17716814081) != 0) || _la == GoogleSQLParserFILTER_SYMBOL || _la == GoogleSQLParserMATCH_SYMBOL || ((int64((_la-355)) & ^0x3f) == 0 && ((int64(1)<<(_la-355))&385) != 0) { + { + p.SetState(1368) + p.Graph_linear_operator() + } + + p.SetState(1371) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_linear_operatorContext is an interface to support dynamic dispatch. +type IGraph_linear_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Graph_match_operator() IGraph_match_operatorContext + Graph_optional_match_operator() IGraph_optional_match_operatorContext + Graph_let_operator() IGraph_let_operatorContext + Graph_filter_operator() IGraph_filter_operatorContext + Graph_order_by_operator() IGraph_order_by_operatorContext + Graph_page_operator() IGraph_page_operatorContext + Graph_with_operator() IGraph_with_operatorContext + Graph_for_operator() IGraph_for_operatorContext + Graph_sample_clause() IGraph_sample_clauseContext + + // IsGraph_linear_operatorContext differentiates from other interfaces. + IsGraph_linear_operatorContext() +} + +type Graph_linear_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_linear_operatorContext() *Graph_linear_operatorContext { + var p = new(Graph_linear_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_linear_operator + return p +} + +func InitEmptyGraph_linear_operatorContext(p *Graph_linear_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_linear_operator +} + +func (*Graph_linear_operatorContext) IsGraph_linear_operatorContext() {} + +func NewGraph_linear_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_linear_operatorContext { + var p = new(Graph_linear_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_linear_operator + + return p +} + +func (s *Graph_linear_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_linear_operatorContext) Graph_match_operator() IGraph_match_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_match_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_match_operatorContext) +} + +func (s *Graph_linear_operatorContext) Graph_optional_match_operator() IGraph_optional_match_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_optional_match_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_optional_match_operatorContext) +} + +func (s *Graph_linear_operatorContext) Graph_let_operator() IGraph_let_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_let_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_let_operatorContext) +} + +func (s *Graph_linear_operatorContext) Graph_filter_operator() IGraph_filter_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_filter_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_filter_operatorContext) +} + +func (s *Graph_linear_operatorContext) Graph_order_by_operator() IGraph_order_by_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_order_by_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_order_by_operatorContext) +} + +func (s *Graph_linear_operatorContext) Graph_page_operator() IGraph_page_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_page_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_page_operatorContext) +} + +func (s *Graph_linear_operatorContext) Graph_with_operator() IGraph_with_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_with_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_with_operatorContext) +} + +func (s *Graph_linear_operatorContext) Graph_for_operator() IGraph_for_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_for_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_for_operatorContext) +} + +func (s *Graph_linear_operatorContext) Graph_sample_clause() IGraph_sample_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_sample_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_sample_clauseContext) +} + +func (s *Graph_linear_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_linear_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_linear_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_linear_operator(s) + } +} + +func (s *Graph_linear_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_linear_operator(s) + } +} + +func (s *Graph_linear_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_linear_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_linear_operator() (localctx IGraph_linear_operatorContext) { + localctx = NewGraph_linear_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 22, GoogleSQLParserRULE_graph_linear_operator) + p.SetState(1382) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserMATCH_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1373) + p.Graph_match_operator() + } + + case GoogleSQLParserOPTIONAL_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1374) + p.Graph_optional_match_operator() + } + + case GoogleSQLParserLET_SYMBOL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1375) + p.Graph_let_operator() + } + + case GoogleSQLParserFILTER_SYMBOL: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1376) + p.Graph_filter_operator() + } + + case GoogleSQLParserORDER_SYMBOL: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1377) + p.Graph_order_by_operator() + } + + case GoogleSQLParserLIMIT_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserSKIP_SYMBOL: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(1378) + p.Graph_page_operator() + } + + case GoogleSQLParserWITH_SYMBOL: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(1379) + p.Graph_with_operator() + } + + case GoogleSQLParserFOR_SYMBOL: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(1380) + p.Graph_for_operator() + } + + case GoogleSQLParserTABLESAMPLE_SYMBOL: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(1381) + p.Graph_sample_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_sample_clauseContext is an interface to support dynamic dispatch. +type IGraph_sample_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLESAMPLE_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + LR_BRACKET_SYMBOL() antlr.TerminalNode + Sample_size() ISample_sizeContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + Opt_graph_sample_clause_suffix() IOpt_graph_sample_clause_suffixContext + + // IsGraph_sample_clauseContext differentiates from other interfaces. + IsGraph_sample_clauseContext() +} + +type Graph_sample_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_sample_clauseContext() *Graph_sample_clauseContext { + var p = new(Graph_sample_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_sample_clause + return p +} + +func InitEmptyGraph_sample_clauseContext(p *Graph_sample_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_sample_clause +} + +func (*Graph_sample_clauseContext) IsGraph_sample_clauseContext() {} + +func NewGraph_sample_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_sample_clauseContext { + var p = new(Graph_sample_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_sample_clause + + return p +} + +func (s *Graph_sample_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_sample_clauseContext) TABLESAMPLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTABLESAMPLE_SYMBOL, 0) +} + +func (s *Graph_sample_clauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Graph_sample_clauseContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Graph_sample_clauseContext) Sample_size() ISample_sizeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISample_sizeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISample_sizeContext) +} + +func (s *Graph_sample_clauseContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Graph_sample_clauseContext) Opt_graph_sample_clause_suffix() IOpt_graph_sample_clause_suffixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_graph_sample_clause_suffixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_graph_sample_clause_suffixContext) +} + +func (s *Graph_sample_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_sample_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_sample_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_sample_clause(s) + } +} + +func (s *Graph_sample_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_sample_clause(s) + } +} + +func (s *Graph_sample_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_sample_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_sample_clause() (localctx IGraph_sample_clauseContext) { + localctx = NewGraph_sample_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 24, GoogleSQLParserRULE_graph_sample_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1384) + p.Match(GoogleSQLParserTABLESAMPLE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1385) + p.Identifier() + } + { + p.SetState(1386) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1387) + p.Sample_size() + } + { + p.SetState(1388) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1390) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 11, p.GetParserRuleContext()) == 1 { + { + p.SetState(1389) + p.Opt_graph_sample_clause_suffix() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_graph_sample_clause_suffixContext is an interface to support dynamic dispatch. +type IOpt_graph_sample_clause_suffixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Repeatable_clause() IRepeatable_clauseContext + WITH_SYMBOL() antlr.TerminalNode + WEIGHT_SYMBOL() antlr.TerminalNode + AS_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsOpt_graph_sample_clause_suffixContext differentiates from other interfaces. + IsOpt_graph_sample_clause_suffixContext() +} + +type Opt_graph_sample_clause_suffixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_graph_sample_clause_suffixContext() *Opt_graph_sample_clause_suffixContext { + var p = new(Opt_graph_sample_clause_suffixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_graph_sample_clause_suffix + return p +} + +func InitEmptyOpt_graph_sample_clause_suffixContext(p *Opt_graph_sample_clause_suffixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_graph_sample_clause_suffix +} + +func (*Opt_graph_sample_clause_suffixContext) IsOpt_graph_sample_clause_suffixContext() {} + +func NewOpt_graph_sample_clause_suffixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_graph_sample_clause_suffixContext { + var p = new(Opt_graph_sample_clause_suffixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_graph_sample_clause_suffix + + return p +} + +func (s *Opt_graph_sample_clause_suffixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_graph_sample_clause_suffixContext) Repeatable_clause() IRepeatable_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRepeatable_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRepeatable_clauseContext) +} + +func (s *Opt_graph_sample_clause_suffixContext) WITH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWITH_SYMBOL, 0) +} + +func (s *Opt_graph_sample_clause_suffixContext) WEIGHT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWEIGHT_SYMBOL, 0) +} + +func (s *Opt_graph_sample_clause_suffixContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Opt_graph_sample_clause_suffixContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Opt_graph_sample_clause_suffixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_graph_sample_clause_suffixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_graph_sample_clause_suffixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_graph_sample_clause_suffix(s) + } +} + +func (s *Opt_graph_sample_clause_suffixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_graph_sample_clause_suffix(s) + } +} + +func (s *Opt_graph_sample_clause_suffixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_graph_sample_clause_suffix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_graph_sample_clause_suffix() (localctx IOpt_graph_sample_clause_suffixContext) { + localctx = NewOpt_graph_sample_clause_suffixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 26, GoogleSQLParserRULE_opt_graph_sample_clause_suffix) + var _la int + + p.SetState(1405) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 14, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1392) + p.Repeatable_clause() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1393) + p.Match(GoogleSQLParserWITH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1394) + p.Match(GoogleSQLParserWEIGHT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1396) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserREPEATABLE_SYMBOL { + { + p.SetState(1395) + p.Repeatable_clause() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1398) + p.Match(GoogleSQLParserWITH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1399) + p.Match(GoogleSQLParserWEIGHT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1400) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1401) + p.Identifier() + } + p.SetState(1403) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserREPEATABLE_SYMBOL { + { + p.SetState(1402) + p.Repeatable_clause() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_for_operatorContext is an interface to support dynamic dispatch. +type IGraph_for_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + IN_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + Opt_with_offset_and_alias_with_required_as() IOpt_with_offset_and_alias_with_required_asContext + + // IsGraph_for_operatorContext differentiates from other interfaces. + IsGraph_for_operatorContext() +} + +type Graph_for_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_for_operatorContext() *Graph_for_operatorContext { + var p = new(Graph_for_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_for_operator + return p +} + +func InitEmptyGraph_for_operatorContext(p *Graph_for_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_for_operator +} + +func (*Graph_for_operatorContext) IsGraph_for_operatorContext() {} + +func NewGraph_for_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_for_operatorContext { + var p = new(Graph_for_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_for_operator + + return p +} + +func (s *Graph_for_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_for_operatorContext) FOR_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFOR_SYMBOL, 0) +} + +func (s *Graph_for_operatorContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Graph_for_operatorContext) IN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIN_SYMBOL, 0) +} + +func (s *Graph_for_operatorContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Graph_for_operatorContext) Opt_with_offset_and_alias_with_required_as() IOpt_with_offset_and_alias_with_required_asContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_with_offset_and_alias_with_required_asContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_with_offset_and_alias_with_required_asContext) +} + +func (s *Graph_for_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_for_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_for_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_for_operator(s) + } +} + +func (s *Graph_for_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_for_operator(s) + } +} + +func (s *Graph_for_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_for_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_for_operator() (localctx IGraph_for_operatorContext) { + localctx = NewGraph_for_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 28, GoogleSQLParserRULE_graph_for_operator) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1407) + p.Match(GoogleSQLParserFOR_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1408) + p.Identifier() + } + { + p.SetState(1409) + p.Match(GoogleSQLParserIN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1410) + p.expression(0) + } + p.SetState(1412) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 15, p.GetParserRuleContext()) == 1 { + { + p.SetState(1411) + p.Opt_with_offset_and_alias_with_required_as() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_with_offset_and_alias_with_required_asContext is an interface to support dynamic dispatch. +type IOpt_with_offset_and_alias_with_required_asContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH_SYMBOL() antlr.TerminalNode + OFFSET_SYMBOL() antlr.TerminalNode + Opt_as_alias_with_required_as() IOpt_as_alias_with_required_asContext + + // IsOpt_with_offset_and_alias_with_required_asContext differentiates from other interfaces. + IsOpt_with_offset_and_alias_with_required_asContext() +} + +type Opt_with_offset_and_alias_with_required_asContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_with_offset_and_alias_with_required_asContext() *Opt_with_offset_and_alias_with_required_asContext { + var p = new(Opt_with_offset_and_alias_with_required_asContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_with_offset_and_alias_with_required_as + return p +} + +func InitEmptyOpt_with_offset_and_alias_with_required_asContext(p *Opt_with_offset_and_alias_with_required_asContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_with_offset_and_alias_with_required_as +} + +func (*Opt_with_offset_and_alias_with_required_asContext) IsOpt_with_offset_and_alias_with_required_asContext() { +} + +func NewOpt_with_offset_and_alias_with_required_asContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_with_offset_and_alias_with_required_asContext { + var p = new(Opt_with_offset_and_alias_with_required_asContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_with_offset_and_alias_with_required_as + + return p +} + +func (s *Opt_with_offset_and_alias_with_required_asContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_with_offset_and_alias_with_required_asContext) WITH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWITH_SYMBOL, 0) +} + +func (s *Opt_with_offset_and_alias_with_required_asContext) OFFSET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOFFSET_SYMBOL, 0) +} + +func (s *Opt_with_offset_and_alias_with_required_asContext) Opt_as_alias_with_required_as() IOpt_as_alias_with_required_asContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_as_alias_with_required_asContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_as_alias_with_required_asContext) +} + +func (s *Opt_with_offset_and_alias_with_required_asContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_with_offset_and_alias_with_required_asContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_with_offset_and_alias_with_required_asContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_with_offset_and_alias_with_required_as(s) + } +} + +func (s *Opt_with_offset_and_alias_with_required_asContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_with_offset_and_alias_with_required_as(s) + } +} + +func (s *Opt_with_offset_and_alias_with_required_asContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_with_offset_and_alias_with_required_as(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_with_offset_and_alias_with_required_as() (localctx IOpt_with_offset_and_alias_with_required_asContext) { + localctx = NewOpt_with_offset_and_alias_with_required_asContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 30, GoogleSQLParserRULE_opt_with_offset_and_alias_with_required_as) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1414) + p.Match(GoogleSQLParserWITH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1415) + p.Match(GoogleSQLParserOFFSET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1417) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(1416) + p.Opt_as_alias_with_required_as() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_with_operatorContext is an interface to support dynamic dispatch. +type IGraph_with_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH_SYMBOL() antlr.TerminalNode + Graph_return_item_list() IGraph_return_item_listContext + All_or_distinct() IAll_or_distinctContext + Hint() IHintContext + Group_by_clause() IGroup_by_clauseContext + + // IsGraph_with_operatorContext differentiates from other interfaces. + IsGraph_with_operatorContext() +} + +type Graph_with_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_with_operatorContext() *Graph_with_operatorContext { + var p = new(Graph_with_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_with_operator + return p +} + +func InitEmptyGraph_with_operatorContext(p *Graph_with_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_with_operator +} + +func (*Graph_with_operatorContext) IsGraph_with_operatorContext() {} + +func NewGraph_with_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_with_operatorContext { + var p = new(Graph_with_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_with_operator + + return p +} + +func (s *Graph_with_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_with_operatorContext) WITH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWITH_SYMBOL, 0) +} + +func (s *Graph_with_operatorContext) Graph_return_item_list() IGraph_return_item_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_return_item_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_return_item_listContext) +} + +func (s *Graph_with_operatorContext) All_or_distinct() IAll_or_distinctContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_or_distinctContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_or_distinctContext) +} + +func (s *Graph_with_operatorContext) Hint() IHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Graph_with_operatorContext) Group_by_clause() IGroup_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGroup_by_clauseContext) +} + +func (s *Graph_with_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_with_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_with_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_with_operator(s) + } +} + +func (s *Graph_with_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_with_operator(s) + } +} + +func (s *Graph_with_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_with_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_with_operator() (localctx IGraph_with_operatorContext) { + localctx = NewGraph_with_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 32, GoogleSQLParserRULE_graph_with_operator) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1419) + p.Match(GoogleSQLParserWITH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1421) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserALL_SYMBOL || _la == GoogleSQLParserDISTINCT_SYMBOL { + { + p.SetState(1420) + p.All_or_distinct() + } + + } + p.SetState(1424) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 18, p.GetParserRuleContext()) == 1 { + { + p.SetState(1423) + p.Hint() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1426) + p.Graph_return_item_list() + } + p.SetState(1428) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserGROUP_SYMBOL { + { + p.SetState(1427) + p.Group_by_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_page_operatorContext is an interface to support dynamic dispatch. +type IGraph_page_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Graph_page_clause() IGraph_page_clauseContext + + // IsGraph_page_operatorContext differentiates from other interfaces. + IsGraph_page_operatorContext() +} + +type Graph_page_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_page_operatorContext() *Graph_page_operatorContext { + var p = new(Graph_page_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_page_operator + return p +} + +func InitEmptyGraph_page_operatorContext(p *Graph_page_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_page_operator +} + +func (*Graph_page_operatorContext) IsGraph_page_operatorContext() {} + +func NewGraph_page_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_page_operatorContext { + var p = new(Graph_page_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_page_operator + + return p +} + +func (s *Graph_page_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_page_operatorContext) Graph_page_clause() IGraph_page_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_page_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_page_clauseContext) +} + +func (s *Graph_page_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_page_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_page_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_page_operator(s) + } +} + +func (s *Graph_page_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_page_operator(s) + } +} + +func (s *Graph_page_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_page_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_page_operator() (localctx IGraph_page_operatorContext) { + localctx = NewGraph_page_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 34, GoogleSQLParserRULE_graph_page_operator) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1430) + p.Graph_page_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_order_by_operatorContext is an interface to support dynamic dispatch. +type IGraph_order_by_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Graph_order_by_clause() IGraph_order_by_clauseContext + + // IsGraph_order_by_operatorContext differentiates from other interfaces. + IsGraph_order_by_operatorContext() +} + +type Graph_order_by_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_order_by_operatorContext() *Graph_order_by_operatorContext { + var p = new(Graph_order_by_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_order_by_operator + return p +} + +func InitEmptyGraph_order_by_operatorContext(p *Graph_order_by_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_order_by_operator +} + +func (*Graph_order_by_operatorContext) IsGraph_order_by_operatorContext() {} + +func NewGraph_order_by_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_order_by_operatorContext { + var p = new(Graph_order_by_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_order_by_operator + + return p +} + +func (s *Graph_order_by_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_order_by_operatorContext) Graph_order_by_clause() IGraph_order_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_order_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_order_by_clauseContext) +} + +func (s *Graph_order_by_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_order_by_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_order_by_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_order_by_operator(s) + } +} + +func (s *Graph_order_by_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_order_by_operator(s) + } +} + +func (s *Graph_order_by_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_order_by_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_order_by_operator() (localctx IGraph_order_by_operatorContext) { + localctx = NewGraph_order_by_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 36, GoogleSQLParserRULE_graph_order_by_operator) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1432) + p.Graph_order_by_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_filter_operatorContext is an interface to support dynamic dispatch. +type IGraph_filter_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FILTER_SYMBOL() antlr.TerminalNode + Where_clause() IWhere_clauseContext + Expression() IExpressionContext + + // IsGraph_filter_operatorContext differentiates from other interfaces. + IsGraph_filter_operatorContext() +} + +type Graph_filter_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_filter_operatorContext() *Graph_filter_operatorContext { + var p = new(Graph_filter_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_filter_operator + return p +} + +func InitEmptyGraph_filter_operatorContext(p *Graph_filter_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_filter_operator +} + +func (*Graph_filter_operatorContext) IsGraph_filter_operatorContext() {} + +func NewGraph_filter_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_filter_operatorContext { + var p = new(Graph_filter_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_filter_operator + + return p +} + +func (s *Graph_filter_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_filter_operatorContext) FILTER_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFILTER_SYMBOL, 0) +} + +func (s *Graph_filter_operatorContext) Where_clause() IWhere_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_clauseContext) +} + +func (s *Graph_filter_operatorContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Graph_filter_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_filter_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_filter_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_filter_operator(s) + } +} + +func (s *Graph_filter_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_filter_operator(s) + } +} + +func (s *Graph_filter_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_filter_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_filter_operator() (localctx IGraph_filter_operatorContext) { + localctx = NewGraph_filter_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 38, GoogleSQLParserRULE_graph_filter_operator) + p.SetState(1438) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 20, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1434) + p.Match(GoogleSQLParserFILTER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1435) + p.Where_clause() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1436) + p.Match(GoogleSQLParserFILTER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1437) + p.expression(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_let_operatorContext is an interface to support dynamic dispatch. +type IGraph_let_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LET_SYMBOL() antlr.TerminalNode + Graph_let_variable_definition_list() IGraph_let_variable_definition_listContext + + // IsGraph_let_operatorContext differentiates from other interfaces. + IsGraph_let_operatorContext() +} + +type Graph_let_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_let_operatorContext() *Graph_let_operatorContext { + var p = new(Graph_let_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_let_operator + return p +} + +func InitEmptyGraph_let_operatorContext(p *Graph_let_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_let_operator +} + +func (*Graph_let_operatorContext) IsGraph_let_operatorContext() {} + +func NewGraph_let_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_let_operatorContext { + var p = new(Graph_let_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_let_operator + + return p +} + +func (s *Graph_let_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_let_operatorContext) LET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLET_SYMBOL, 0) +} + +func (s *Graph_let_operatorContext) Graph_let_variable_definition_list() IGraph_let_variable_definition_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_let_variable_definition_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_let_variable_definition_listContext) +} + +func (s *Graph_let_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_let_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_let_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_let_operator(s) + } +} + +func (s *Graph_let_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_let_operator(s) + } +} + +func (s *Graph_let_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_let_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_let_operator() (localctx IGraph_let_operatorContext) { + localctx = NewGraph_let_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 40, GoogleSQLParserRULE_graph_let_operator) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1440) + p.Match(GoogleSQLParserLET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1441) + p.Graph_let_variable_definition_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_let_variable_definition_listContext is an interface to support dynamic dispatch. +type IGraph_let_variable_definition_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllGraph_let_variable_definition() []IGraph_let_variable_definitionContext + Graph_let_variable_definition(i int) IGraph_let_variable_definitionContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsGraph_let_variable_definition_listContext differentiates from other interfaces. + IsGraph_let_variable_definition_listContext() +} + +type Graph_let_variable_definition_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_let_variable_definition_listContext() *Graph_let_variable_definition_listContext { + var p = new(Graph_let_variable_definition_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_let_variable_definition_list + return p +} + +func InitEmptyGraph_let_variable_definition_listContext(p *Graph_let_variable_definition_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_let_variable_definition_list +} + +func (*Graph_let_variable_definition_listContext) IsGraph_let_variable_definition_listContext() {} + +func NewGraph_let_variable_definition_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_let_variable_definition_listContext { + var p = new(Graph_let_variable_definition_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_let_variable_definition_list + + return p +} + +func (s *Graph_let_variable_definition_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_let_variable_definition_listContext) AllGraph_let_variable_definition() []IGraph_let_variable_definitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGraph_let_variable_definitionContext); ok { + len++ + } + } + + tst := make([]IGraph_let_variable_definitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGraph_let_variable_definitionContext); ok { + tst[i] = t.(IGraph_let_variable_definitionContext) + i++ + } + } + + return tst +} + +func (s *Graph_let_variable_definition_listContext) Graph_let_variable_definition(i int) IGraph_let_variable_definitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_let_variable_definitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGraph_let_variable_definitionContext) +} + +func (s *Graph_let_variable_definition_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Graph_let_variable_definition_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Graph_let_variable_definition_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_let_variable_definition_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_let_variable_definition_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_let_variable_definition_list(s) + } +} + +func (s *Graph_let_variable_definition_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_let_variable_definition_list(s) + } +} + +func (s *Graph_let_variable_definition_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_let_variable_definition_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_let_variable_definition_list() (localctx IGraph_let_variable_definition_listContext) { + localctx = NewGraph_let_variable_definition_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 42, GoogleSQLParserRULE_graph_let_variable_definition_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1443) + p.Graph_let_variable_definition() + } + p.SetState(1448) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(1444) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1445) + p.Graph_let_variable_definition() + } + + p.SetState(1450) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_let_variable_definitionContext is an interface to support dynamic dispatch. +type IGraph_let_variable_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + EQUAL_OPERATOR() antlr.TerminalNode + Expression() IExpressionContext + + // IsGraph_let_variable_definitionContext differentiates from other interfaces. + IsGraph_let_variable_definitionContext() +} + +type Graph_let_variable_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_let_variable_definitionContext() *Graph_let_variable_definitionContext { + var p = new(Graph_let_variable_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_let_variable_definition + return p +} + +func InitEmptyGraph_let_variable_definitionContext(p *Graph_let_variable_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_let_variable_definition +} + +func (*Graph_let_variable_definitionContext) IsGraph_let_variable_definitionContext() {} + +func NewGraph_let_variable_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_let_variable_definitionContext { + var p = new(Graph_let_variable_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_let_variable_definition + + return p +} + +func (s *Graph_let_variable_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_let_variable_definitionContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Graph_let_variable_definitionContext) EQUAL_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEQUAL_OPERATOR, 0) +} + +func (s *Graph_let_variable_definitionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Graph_let_variable_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_let_variable_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_let_variable_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_let_variable_definition(s) + } +} + +func (s *Graph_let_variable_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_let_variable_definition(s) + } +} + +func (s *Graph_let_variable_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_let_variable_definition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_let_variable_definition() (localctx IGraph_let_variable_definitionContext) { + localctx = NewGraph_let_variable_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 44, GoogleSQLParserRULE_graph_let_variable_definition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1451) + p.Identifier() + } + { + p.SetState(1452) + p.Match(GoogleSQLParserEQUAL_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1453) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_optional_match_operatorContext is an interface to support dynamic dispatch. +type IGraph_optional_match_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPTIONAL_SYMBOL() antlr.TerminalNode + MATCH_SYMBOL() antlr.TerminalNode + Graph_pattern() IGraph_patternContext + Hint() IHintContext + + // IsGraph_optional_match_operatorContext differentiates from other interfaces. + IsGraph_optional_match_operatorContext() +} + +type Graph_optional_match_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_optional_match_operatorContext() *Graph_optional_match_operatorContext { + var p = new(Graph_optional_match_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_optional_match_operator + return p +} + +func InitEmptyGraph_optional_match_operatorContext(p *Graph_optional_match_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_optional_match_operator +} + +func (*Graph_optional_match_operatorContext) IsGraph_optional_match_operatorContext() {} + +func NewGraph_optional_match_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_optional_match_operatorContext { + var p = new(Graph_optional_match_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_optional_match_operator + + return p +} + +func (s *Graph_optional_match_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_optional_match_operatorContext) OPTIONAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOPTIONAL_SYMBOL, 0) +} + +func (s *Graph_optional_match_operatorContext) MATCH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMATCH_SYMBOL, 0) +} + +func (s *Graph_optional_match_operatorContext) Graph_pattern() IGraph_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_patternContext) +} + +func (s *Graph_optional_match_operatorContext) Hint() IHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Graph_optional_match_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_optional_match_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_optional_match_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_optional_match_operator(s) + } +} + +func (s *Graph_optional_match_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_optional_match_operator(s) + } +} + +func (s *Graph_optional_match_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_optional_match_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_optional_match_operator() (localctx IGraph_optional_match_operatorContext) { + localctx = NewGraph_optional_match_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 46, GoogleSQLParserRULE_graph_optional_match_operator) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1455) + p.Match(GoogleSQLParserOPTIONAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1456) + p.Match(GoogleSQLParserMATCH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1458) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(1457) + p.Hint() + } + + } + { + p.SetState(1460) + p.Graph_pattern() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_match_operatorContext is an interface to support dynamic dispatch. +type IGraph_match_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MATCH_SYMBOL() antlr.TerminalNode + Graph_pattern() IGraph_patternContext + Hint() IHintContext + + // IsGraph_match_operatorContext differentiates from other interfaces. + IsGraph_match_operatorContext() +} + +type Graph_match_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_match_operatorContext() *Graph_match_operatorContext { + var p = new(Graph_match_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_match_operator + return p +} + +func InitEmptyGraph_match_operatorContext(p *Graph_match_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_match_operator +} + +func (*Graph_match_operatorContext) IsGraph_match_operatorContext() {} + +func NewGraph_match_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_match_operatorContext { + var p = new(Graph_match_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_match_operator + + return p +} + +func (s *Graph_match_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_match_operatorContext) MATCH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMATCH_SYMBOL, 0) +} + +func (s *Graph_match_operatorContext) Graph_pattern() IGraph_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_patternContext) +} + +func (s *Graph_match_operatorContext) Hint() IHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Graph_match_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_match_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_match_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_match_operator(s) + } +} + +func (s *Graph_match_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_match_operator(s) + } +} + +func (s *Graph_match_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_match_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_match_operator() (localctx IGraph_match_operatorContext) { + localctx = NewGraph_match_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 48, GoogleSQLParserRULE_graph_match_operator) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1462) + p.Match(GoogleSQLParserMATCH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1464) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(1463) + p.Hint() + } + + } + { + p.SetState(1466) + p.Graph_pattern() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_patternContext is an interface to support dynamic dispatch. +type IGraph_patternContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Graph_path_pattern_list() IGraph_path_pattern_listContext + Where_clause() IWhere_clauseContext + + // IsGraph_patternContext differentiates from other interfaces. + IsGraph_patternContext() +} + +type Graph_patternContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_patternContext() *Graph_patternContext { + var p = new(Graph_patternContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_pattern + return p +} + +func InitEmptyGraph_patternContext(p *Graph_patternContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_pattern +} + +func (*Graph_patternContext) IsGraph_patternContext() {} + +func NewGraph_patternContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_patternContext { + var p = new(Graph_patternContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_pattern + + return p +} + +func (s *Graph_patternContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_patternContext) Graph_path_pattern_list() IGraph_path_pattern_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_path_pattern_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_path_pattern_listContext) +} + +func (s *Graph_patternContext) Where_clause() IWhere_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_clauseContext) +} + +func (s *Graph_patternContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_patternContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_patternContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_pattern(s) + } +} + +func (s *Graph_patternContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_pattern(s) + } +} + +func (s *Graph_patternContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_pattern(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_pattern() (localctx IGraph_patternContext) { + localctx = NewGraph_patternContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 50, GoogleSQLParserRULE_graph_pattern) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1468) + p.Graph_path_pattern_list() + } + p.SetState(1470) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWHERE_SYMBOL { + { + p.SetState(1469) + p.Where_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_path_pattern_listContext is an interface to support dynamic dispatch. +type IGraph_path_pattern_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllGraph_path_pattern() []IGraph_path_patternContext + Graph_path_pattern(i int) IGraph_path_patternContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + AllHint() []IHintContext + Hint(i int) IHintContext + + // IsGraph_path_pattern_listContext differentiates from other interfaces. + IsGraph_path_pattern_listContext() +} + +type Graph_path_pattern_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_path_pattern_listContext() *Graph_path_pattern_listContext { + var p = new(Graph_path_pattern_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_path_pattern_list + return p +} + +func InitEmptyGraph_path_pattern_listContext(p *Graph_path_pattern_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_path_pattern_list +} + +func (*Graph_path_pattern_listContext) IsGraph_path_pattern_listContext() {} + +func NewGraph_path_pattern_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_path_pattern_listContext { + var p = new(Graph_path_pattern_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_path_pattern_list + + return p +} + +func (s *Graph_path_pattern_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_path_pattern_listContext) AllGraph_path_pattern() []IGraph_path_patternContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGraph_path_patternContext); ok { + len++ + } + } + + tst := make([]IGraph_path_patternContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGraph_path_patternContext); ok { + tst[i] = t.(IGraph_path_patternContext) + i++ + } + } + + return tst +} + +func (s *Graph_path_pattern_listContext) Graph_path_pattern(i int) IGraph_path_patternContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_path_patternContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGraph_path_patternContext) +} + +func (s *Graph_path_pattern_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Graph_path_pattern_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Graph_path_pattern_listContext) AllHint() []IHintContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IHintContext); ok { + len++ + } + } + + tst := make([]IHintContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IHintContext); ok { + tst[i] = t.(IHintContext) + i++ + } + } + + return tst +} + +func (s *Graph_path_pattern_listContext) Hint(i int) IHintContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Graph_path_pattern_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_path_pattern_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_path_pattern_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_path_pattern_list(s) + } +} + +func (s *Graph_path_pattern_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_path_pattern_list(s) + } +} + +func (s *Graph_path_pattern_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_path_pattern_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_path_pattern_list() (localctx IGraph_path_pattern_listContext) { + localctx = NewGraph_path_pattern_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 52, GoogleSQLParserRULE_graph_path_pattern_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1472) + p.Graph_path_pattern() + } + p.SetState(1480) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(1473) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1475) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(1474) + p.Hint() + } + + } + { + p.SetState(1477) + p.Graph_path_pattern() + } + + p.SetState(1482) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_path_patternContext is an interface to support dynamic dispatch. +type IGraph_path_patternContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Graph_path_pattern_expr() IGraph_path_pattern_exprContext + Opt_path_variable_assignment() IOpt_path_variable_assignmentContext + Opt_graph_search_prefix() IOpt_graph_search_prefixContext + Opt_graph_path_mode_prefix() IOpt_graph_path_mode_prefixContext + + // IsGraph_path_patternContext differentiates from other interfaces. + IsGraph_path_patternContext() +} + +type Graph_path_patternContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_path_patternContext() *Graph_path_patternContext { + var p = new(Graph_path_patternContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_path_pattern + return p +} + +func InitEmptyGraph_path_patternContext(p *Graph_path_patternContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_path_pattern +} + +func (*Graph_path_patternContext) IsGraph_path_patternContext() {} + +func NewGraph_path_patternContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_path_patternContext { + var p = new(Graph_path_patternContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_path_pattern + + return p +} + +func (s *Graph_path_patternContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_path_patternContext) Graph_path_pattern_expr() IGraph_path_pattern_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_path_pattern_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_path_pattern_exprContext) +} + +func (s *Graph_path_patternContext) Opt_path_variable_assignment() IOpt_path_variable_assignmentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_path_variable_assignmentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_path_variable_assignmentContext) +} + +func (s *Graph_path_patternContext) Opt_graph_search_prefix() IOpt_graph_search_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_graph_search_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_graph_search_prefixContext) +} + +func (s *Graph_path_patternContext) Opt_graph_path_mode_prefix() IOpt_graph_path_mode_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_graph_path_mode_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_graph_path_mode_prefixContext) +} + +func (s *Graph_path_patternContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_path_patternContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_path_patternContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_path_pattern(s) + } +} + +func (s *Graph_path_patternContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_path_pattern(s) + } +} + +func (s *Graph_path_patternContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_path_pattern(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_path_pattern() (localctx IGraph_path_patternContext) { + localctx = NewGraph_path_patternContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 54, GoogleSQLParserRULE_graph_path_pattern) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(1484) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 27, p.GetParserRuleContext()) == 1 { + { + p.SetState(1483) + p.Opt_path_variable_assignment() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(1487) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserALL_SYMBOL || _la == GoogleSQLParserANY_SYMBOL { + { + p.SetState(1486) + p.Opt_graph_search_prefix() + } + + } + p.SetState(1490) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserSIMPLE_SYMBOL || ((int64((_la-359)) & ^0x3f) == 0 && ((int64(1)<<(_la-359))&7) != 0) { + { + p.SetState(1489) + p.Opt_graph_path_mode_prefix() + } + + } + { + p.SetState(1492) + p.Graph_path_pattern_expr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_path_pattern_exprContext is an interface to support dynamic dispatch. +type IGraph_path_pattern_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllGraph_path_factor() []IGraph_path_factorContext + Graph_path_factor(i int) IGraph_path_factorContext + AllHint() []IHintContext + Hint(i int) IHintContext + + // IsGraph_path_pattern_exprContext differentiates from other interfaces. + IsGraph_path_pattern_exprContext() +} + +type Graph_path_pattern_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_path_pattern_exprContext() *Graph_path_pattern_exprContext { + var p = new(Graph_path_pattern_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_path_pattern_expr + return p +} + +func InitEmptyGraph_path_pattern_exprContext(p *Graph_path_pattern_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_path_pattern_expr +} + +func (*Graph_path_pattern_exprContext) IsGraph_path_pattern_exprContext() {} + +func NewGraph_path_pattern_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_path_pattern_exprContext { + var p = new(Graph_path_pattern_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_path_pattern_expr + + return p +} + +func (s *Graph_path_pattern_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_path_pattern_exprContext) AllGraph_path_factor() []IGraph_path_factorContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGraph_path_factorContext); ok { + len++ + } + } + + tst := make([]IGraph_path_factorContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGraph_path_factorContext); ok { + tst[i] = t.(IGraph_path_factorContext) + i++ + } + } + + return tst +} + +func (s *Graph_path_pattern_exprContext) Graph_path_factor(i int) IGraph_path_factorContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_path_factorContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGraph_path_factorContext) +} + +func (s *Graph_path_pattern_exprContext) AllHint() []IHintContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IHintContext); ok { + len++ + } + } + + tst := make([]IHintContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IHintContext); ok { + tst[i] = t.(IHintContext) + i++ + } + } + + return tst +} + +func (s *Graph_path_pattern_exprContext) Hint(i int) IHintContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Graph_path_pattern_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_path_pattern_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_path_pattern_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_path_pattern_expr(s) + } +} + +func (s *Graph_path_pattern_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_path_pattern_expr(s) + } +} + +func (s *Graph_path_pattern_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_path_pattern_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_path_pattern_expr() (localctx IGraph_path_pattern_exprContext) { + localctx = NewGraph_path_pattern_exprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 56, GoogleSQLParserRULE_graph_path_pattern_expr) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1494) + p.Graph_path_factor() + } + p.SetState(1501) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for (int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&154620921872) != 0 { + p.SetState(1496) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(1495) + p.Hint() + } + + } + { + p.SetState(1498) + p.Graph_path_factor() + } + + p.SetState(1503) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_path_factorContext is an interface to support dynamic dispatch. +type IGraph_path_factorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Graph_path_primary() IGraph_path_primaryContext + Graph_quantified_path_primary() IGraph_quantified_path_primaryContext + + // IsGraph_path_factorContext differentiates from other interfaces. + IsGraph_path_factorContext() +} + +type Graph_path_factorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_path_factorContext() *Graph_path_factorContext { + var p = new(Graph_path_factorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_path_factor + return p +} + +func InitEmptyGraph_path_factorContext(p *Graph_path_factorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_path_factor +} + +func (*Graph_path_factorContext) IsGraph_path_factorContext() {} + +func NewGraph_path_factorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_path_factorContext { + var p = new(Graph_path_factorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_path_factor + + return p +} + +func (s *Graph_path_factorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_path_factorContext) Graph_path_primary() IGraph_path_primaryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_path_primaryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_path_primaryContext) +} + +func (s *Graph_path_factorContext) Graph_quantified_path_primary() IGraph_quantified_path_primaryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_quantified_path_primaryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_quantified_path_primaryContext) +} + +func (s *Graph_path_factorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_path_factorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_path_factorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_path_factor(s) + } +} + +func (s *Graph_path_factorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_path_factor(s) + } +} + +func (s *Graph_path_factorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_path_factor(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_path_factor() (localctx IGraph_path_factorContext) { + localctx = NewGraph_path_factorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 58, GoogleSQLParserRULE_graph_path_factor) + p.SetState(1506) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 32, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1504) + p.Graph_path_primary() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1505) + p.Graph_quantified_path_primary() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_quantified_path_primaryContext is an interface to support dynamic dispatch. +type IGraph_quantified_path_primaryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Graph_path_primary() IGraph_path_primaryContext + LC_BRACKET_SYMBOL() antlr.TerminalNode + COMMA_SYMBOL() antlr.TerminalNode + AllInt_literal_or_parameter() []IInt_literal_or_parameterContext + Int_literal_or_parameter(i int) IInt_literal_or_parameterContext + RC_BRACKET_SYMBOL() antlr.TerminalNode + + // IsGraph_quantified_path_primaryContext differentiates from other interfaces. + IsGraph_quantified_path_primaryContext() +} + +type Graph_quantified_path_primaryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_quantified_path_primaryContext() *Graph_quantified_path_primaryContext { + var p = new(Graph_quantified_path_primaryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_quantified_path_primary + return p +} + +func InitEmptyGraph_quantified_path_primaryContext(p *Graph_quantified_path_primaryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_quantified_path_primary +} + +func (*Graph_quantified_path_primaryContext) IsGraph_quantified_path_primaryContext() {} + +func NewGraph_quantified_path_primaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_quantified_path_primaryContext { + var p = new(Graph_quantified_path_primaryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_quantified_path_primary + + return p +} + +func (s *Graph_quantified_path_primaryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_quantified_path_primaryContext) Graph_path_primary() IGraph_path_primaryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_path_primaryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_path_primaryContext) +} + +func (s *Graph_quantified_path_primaryContext) LC_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLC_BRACKET_SYMBOL, 0) +} + +func (s *Graph_quantified_path_primaryContext) COMMA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, 0) +} + +func (s *Graph_quantified_path_primaryContext) AllInt_literal_or_parameter() []IInt_literal_or_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInt_literal_or_parameterContext); ok { + len++ + } + } + + tst := make([]IInt_literal_or_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInt_literal_or_parameterContext); ok { + tst[i] = t.(IInt_literal_or_parameterContext) + i++ + } + } + + return tst +} + +func (s *Graph_quantified_path_primaryContext) Int_literal_or_parameter(i int) IInt_literal_or_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInt_literal_or_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInt_literal_or_parameterContext) +} + +func (s *Graph_quantified_path_primaryContext) RC_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRC_BRACKET_SYMBOL, 0) +} + +func (s *Graph_quantified_path_primaryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_quantified_path_primaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_quantified_path_primaryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_quantified_path_primary(s) + } +} + +func (s *Graph_quantified_path_primaryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_quantified_path_primary(s) + } +} + +func (s *Graph_quantified_path_primaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_quantified_path_primary(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_quantified_path_primary() (localctx IGraph_quantified_path_primaryContext) { + localctx = NewGraph_quantified_path_primaryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 60, GoogleSQLParserRULE_graph_quantified_path_primary) + var _la int + + p.SetState(1522) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 34, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1508) + p.Graph_path_primary() + } + { + p.SetState(1509) + p.Match(GoogleSQLParserLC_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1511) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&36028857148506112) != 0 { + { + p.SetState(1510) + p.Int_literal_or_parameter() + } + + } + { + p.SetState(1513) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1514) + p.Int_literal_or_parameter() + } + { + p.SetState(1515) + p.Match(GoogleSQLParserRC_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1517) + p.Graph_path_primary() + } + { + p.SetState(1518) + p.Match(GoogleSQLParserLC_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1519) + p.Int_literal_or_parameter() + } + { + p.SetState(1520) + p.Match(GoogleSQLParserRC_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_path_primaryContext is an interface to support dynamic dispatch. +type IGraph_path_primaryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Graph_element_pattern() IGraph_element_patternContext + Graph_parenthesized_path_pattern() IGraph_parenthesized_path_patternContext + + // IsGraph_path_primaryContext differentiates from other interfaces. + IsGraph_path_primaryContext() +} + +type Graph_path_primaryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_path_primaryContext() *Graph_path_primaryContext { + var p = new(Graph_path_primaryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_path_primary + return p +} + +func InitEmptyGraph_path_primaryContext(p *Graph_path_primaryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_path_primary +} + +func (*Graph_path_primaryContext) IsGraph_path_primaryContext() {} + +func NewGraph_path_primaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_path_primaryContext { + var p = new(Graph_path_primaryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_path_primary + + return p +} + +func (s *Graph_path_primaryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_path_primaryContext) Graph_element_pattern() IGraph_element_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_element_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_element_patternContext) +} + +func (s *Graph_path_primaryContext) Graph_parenthesized_path_pattern() IGraph_parenthesized_path_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_parenthesized_path_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_parenthesized_path_patternContext) +} + +func (s *Graph_path_primaryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_path_primaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_path_primaryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_path_primary(s) + } +} + +func (s *Graph_path_primaryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_path_primary(s) + } +} + +func (s *Graph_path_primaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_path_primary(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_path_primary() (localctx IGraph_path_primaryContext) { + localctx = NewGraph_path_primaryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 62, GoogleSQLParserRULE_graph_path_primary) + p.SetState(1526) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 35, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1524) + p.Graph_element_pattern() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1525) + p.Graph_parenthesized_path_pattern() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_parenthesized_path_patternContext is an interface to support dynamic dispatch. +type IGraph_parenthesized_path_patternContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + Graph_path_pattern() IGraph_path_patternContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + Hint() IHintContext + Where_clause() IWhere_clauseContext + + // IsGraph_parenthesized_path_patternContext differentiates from other interfaces. + IsGraph_parenthesized_path_patternContext() +} + +type Graph_parenthesized_path_patternContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_parenthesized_path_patternContext() *Graph_parenthesized_path_patternContext { + var p = new(Graph_parenthesized_path_patternContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_parenthesized_path_pattern + return p +} + +func InitEmptyGraph_parenthesized_path_patternContext(p *Graph_parenthesized_path_patternContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_parenthesized_path_pattern +} + +func (*Graph_parenthesized_path_patternContext) IsGraph_parenthesized_path_patternContext() {} + +func NewGraph_parenthesized_path_patternContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_parenthesized_path_patternContext { + var p = new(Graph_parenthesized_path_patternContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_parenthesized_path_pattern + + return p +} + +func (s *Graph_parenthesized_path_patternContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_parenthesized_path_patternContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Graph_parenthesized_path_patternContext) Graph_path_pattern() IGraph_path_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_path_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_path_patternContext) +} + +func (s *Graph_parenthesized_path_patternContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Graph_parenthesized_path_patternContext) Hint() IHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Graph_parenthesized_path_patternContext) Where_clause() IWhere_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_clauseContext) +} + +func (s *Graph_parenthesized_path_patternContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_parenthesized_path_patternContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_parenthesized_path_patternContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_parenthesized_path_pattern(s) + } +} + +func (s *Graph_parenthesized_path_patternContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_parenthesized_path_pattern(s) + } +} + +func (s *Graph_parenthesized_path_patternContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_parenthesized_path_pattern(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_parenthesized_path_pattern() (localctx IGraph_parenthesized_path_patternContext) { + localctx = NewGraph_parenthesized_path_patternContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 64, GoogleSQLParserRULE_graph_parenthesized_path_pattern) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1528) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1530) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(1529) + p.Hint() + } + + } + { + p.SetState(1532) + p.Graph_path_pattern() + } + p.SetState(1534) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWHERE_SYMBOL { + { + p.SetState(1533) + p.Where_clause() + } + + } + { + p.SetState(1536) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_element_patternContext is an interface to support dynamic dispatch. +type IGraph_element_patternContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Graph_node_pattern() IGraph_node_patternContext + Graph_edge_pattern() IGraph_edge_patternContext + + // IsGraph_element_patternContext differentiates from other interfaces. + IsGraph_element_patternContext() +} + +type Graph_element_patternContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_element_patternContext() *Graph_element_patternContext { + var p = new(Graph_element_patternContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_element_pattern + return p +} + +func InitEmptyGraph_element_patternContext(p *Graph_element_patternContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_element_pattern +} + +func (*Graph_element_patternContext) IsGraph_element_patternContext() {} + +func NewGraph_element_patternContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_element_patternContext { + var p = new(Graph_element_patternContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_element_pattern + + return p +} + +func (s *Graph_element_patternContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_element_patternContext) Graph_node_pattern() IGraph_node_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_node_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_node_patternContext) +} + +func (s *Graph_element_patternContext) Graph_edge_pattern() IGraph_edge_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_edge_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_edge_patternContext) +} + +func (s *Graph_element_patternContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_element_patternContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_element_patternContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_element_pattern(s) + } +} + +func (s *Graph_element_patternContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_element_pattern(s) + } +} + +func (s *Graph_element_patternContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_element_pattern(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_element_pattern() (localctx IGraph_element_patternContext) { + localctx = NewGraph_element_patternContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 66, GoogleSQLParserRULE_graph_element_pattern) + p.SetState(1540) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserLR_BRACKET_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1538) + p.Graph_node_pattern() + } + + case GoogleSQLParserLT_OPERATOR, GoogleSQLParserMINUS_OPERATOR, GoogleSQLParserSUB_GT_BRACKET_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1539) + p.Graph_edge_pattern() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_edge_patternContext is an interface to support dynamic dispatch. +type IGraph_edge_patternContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllMINUS_OPERATOR() []antlr.TerminalNode + MINUS_OPERATOR(i int) antlr.TerminalNode + LS_BRACKET_SYMBOL() antlr.TerminalNode + Graph_element_pattern_filler() IGraph_element_pattern_fillerContext + RS_BRACKET_SYMBOL() antlr.TerminalNode + LT_OPERATOR() antlr.TerminalNode + SUB_GT_BRACKET_SYMBOL() antlr.TerminalNode + + // IsGraph_edge_patternContext differentiates from other interfaces. + IsGraph_edge_patternContext() +} + +type Graph_edge_patternContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_edge_patternContext() *Graph_edge_patternContext { + var p = new(Graph_edge_patternContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_edge_pattern + return p +} + +func InitEmptyGraph_edge_patternContext(p *Graph_edge_patternContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_edge_pattern +} + +func (*Graph_edge_patternContext) IsGraph_edge_patternContext() {} + +func NewGraph_edge_patternContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_edge_patternContext { + var p = new(Graph_edge_patternContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_edge_pattern + + return p +} + +func (s *Graph_edge_patternContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_edge_patternContext) AllMINUS_OPERATOR() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserMINUS_OPERATOR) +} + +func (s *Graph_edge_patternContext) MINUS_OPERATOR(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMINUS_OPERATOR, i) +} + +func (s *Graph_edge_patternContext) LS_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLS_BRACKET_SYMBOL, 0) +} + +func (s *Graph_edge_patternContext) Graph_element_pattern_filler() IGraph_element_pattern_fillerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_element_pattern_fillerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_element_pattern_fillerContext) +} + +func (s *Graph_edge_patternContext) RS_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRS_BRACKET_SYMBOL, 0) +} + +func (s *Graph_edge_patternContext) LT_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLT_OPERATOR, 0) +} + +func (s *Graph_edge_patternContext) SUB_GT_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSUB_GT_BRACKET_SYMBOL, 0) +} + +func (s *Graph_edge_patternContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_edge_patternContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_edge_patternContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_edge_pattern(s) + } +} + +func (s *Graph_edge_patternContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_edge_pattern(s) + } +} + +func (s *Graph_edge_patternContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_edge_pattern(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_edge_pattern() (localctx IGraph_edge_patternContext) { + localctx = NewGraph_edge_patternContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 68, GoogleSQLParserRULE_graph_edge_pattern) + var _la int + + p.SetState(1561) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 40, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(1543) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLT_OPERATOR { + { + p.SetState(1542) + p.Match(GoogleSQLParserLT_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1545) + p.Match(GoogleSQLParserMINUS_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1546) + p.Match(GoogleSQLParserLS_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1547) + p.Graph_element_pattern_filler() + } + { + p.SetState(1548) + p.Match(GoogleSQLParserRS_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1549) + p.Match(GoogleSQLParserMINUS_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1551) + p.Match(GoogleSQLParserMINUS_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1552) + p.Match(GoogleSQLParserLS_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1553) + p.Graph_element_pattern_filler() + } + { + p.SetState(1554) + p.Match(GoogleSQLParserRS_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1555) + p.Match(GoogleSQLParserSUB_GT_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1557) + p.Match(GoogleSQLParserMINUS_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1558) + p.Match(GoogleSQLParserLT_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1559) + p.Match(GoogleSQLParserMINUS_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1560) + p.Match(GoogleSQLParserSUB_GT_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_node_patternContext is an interface to support dynamic dispatch. +type IGraph_node_patternContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + Graph_element_pattern_filler() IGraph_element_pattern_fillerContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsGraph_node_patternContext differentiates from other interfaces. + IsGraph_node_patternContext() +} + +type Graph_node_patternContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_node_patternContext() *Graph_node_patternContext { + var p = new(Graph_node_patternContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_node_pattern + return p +} + +func InitEmptyGraph_node_patternContext(p *Graph_node_patternContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_node_pattern +} + +func (*Graph_node_patternContext) IsGraph_node_patternContext() {} + +func NewGraph_node_patternContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_node_patternContext { + var p = new(Graph_node_patternContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_node_pattern + + return p +} + +func (s *Graph_node_patternContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_node_patternContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Graph_node_patternContext) Graph_element_pattern_filler() IGraph_element_pattern_fillerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_element_pattern_fillerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_element_pattern_fillerContext) +} + +func (s *Graph_node_patternContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Graph_node_patternContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_node_patternContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_node_patternContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_node_pattern(s) + } +} + +func (s *Graph_node_patternContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_node_pattern(s) + } +} + +func (s *Graph_node_patternContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_node_pattern(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_node_pattern() (localctx IGraph_node_patternContext) { + localctx = NewGraph_node_patternContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 70, GoogleSQLParserRULE_graph_node_pattern) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1563) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1564) + p.Graph_element_pattern_filler() + } + { + p.SetState(1565) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_element_pattern_fillerContext is an interface to support dynamic dispatch. +type IGraph_element_pattern_fillerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Hint() IHintContext + Opt_graph_element_identifier() IOpt_graph_element_identifierContext + Opt_is_label_expression() IOpt_is_label_expressionContext + Graph_property_specification() IGraph_property_specificationContext + Where_clause() IWhere_clauseContext + + // IsGraph_element_pattern_fillerContext differentiates from other interfaces. + IsGraph_element_pattern_fillerContext() +} + +type Graph_element_pattern_fillerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_element_pattern_fillerContext() *Graph_element_pattern_fillerContext { + var p = new(Graph_element_pattern_fillerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_element_pattern_filler + return p +} + +func InitEmptyGraph_element_pattern_fillerContext(p *Graph_element_pattern_fillerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_element_pattern_filler +} + +func (*Graph_element_pattern_fillerContext) IsGraph_element_pattern_fillerContext() {} + +func NewGraph_element_pattern_fillerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_element_pattern_fillerContext { + var p = new(Graph_element_pattern_fillerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_element_pattern_filler + + return p +} + +func (s *Graph_element_pattern_fillerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_element_pattern_fillerContext) Hint() IHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Graph_element_pattern_fillerContext) Opt_graph_element_identifier() IOpt_graph_element_identifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_graph_element_identifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_graph_element_identifierContext) +} + +func (s *Graph_element_pattern_fillerContext) Opt_is_label_expression() IOpt_is_label_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_is_label_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_is_label_expressionContext) +} + +func (s *Graph_element_pattern_fillerContext) Graph_property_specification() IGraph_property_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_property_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_property_specificationContext) +} + +func (s *Graph_element_pattern_fillerContext) Where_clause() IWhere_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_clauseContext) +} + +func (s *Graph_element_pattern_fillerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_element_pattern_fillerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_element_pattern_fillerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_element_pattern_filler(s) + } +} + +func (s *Graph_element_pattern_fillerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_element_pattern_filler(s) + } +} + +func (s *Graph_element_pattern_fillerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_element_pattern_filler(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_element_pattern_filler() (localctx IGraph_element_pattern_fillerContext) { + localctx = NewGraph_element_pattern_fillerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 72, GoogleSQLParserRULE_graph_element_pattern_filler) + var _la int + + p.SetState(1598) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 49, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(1568) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(1567) + p.Hint() + } + + } + p.SetState(1571) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-74)) & ^0x3f) == 0 && ((int64(1)<<(_la-74))&-247260703569407) != 0) || ((int64((_la-138)) & ^0x3f) == 0 && ((int64(1)<<(_la-138))&-1) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-36028797018963969) != 0) || ((int64((_la-266)) & ^0x3f) == 0 && ((int64(1)<<(_la-266))&536870911) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&33488865) != 0) { + { + p.SetState(1570) + p.Opt_graph_element_identifier() + } + + } + p.SetState(1574) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCOLON_SYMBOL || _la == GoogleSQLParserIS_SYMBOL { + { + p.SetState(1573) + p.Opt_is_label_expression() + } + + } + p.SetState(1577) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLC_BRACKET_SYMBOL { + { + p.SetState(1576) + p.Graph_property_specification() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(1580) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(1579) + p.Hint() + } + + } + { + p.SetState(1582) + p.Opt_graph_element_identifier() + } + p.SetState(1584) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCOLON_SYMBOL || _la == GoogleSQLParserIS_SYMBOL { + { + p.SetState(1583) + p.Opt_is_label_expression() + } + + } + { + p.SetState(1586) + p.Where_clause() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + p.SetState(1589) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(1588) + p.Hint() + } + + } + { + p.SetState(1591) + p.Opt_graph_element_identifier() + } + p.SetState(1593) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCOLON_SYMBOL || _la == GoogleSQLParserIS_SYMBOL { + { + p.SetState(1592) + p.Opt_is_label_expression() + } + + } + { + p.SetState(1595) + p.Graph_property_specification() + } + { + p.SetState(1596) + p.Where_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_property_specificationContext is an interface to support dynamic dispatch. +type IGraph_property_specificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LC_BRACKET_SYMBOL() antlr.TerminalNode + AllGraph_property_name_and_value() []IGraph_property_name_and_valueContext + Graph_property_name_and_value(i int) IGraph_property_name_and_valueContext + RC_BRACKET_SYMBOL() antlr.TerminalNode + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsGraph_property_specificationContext differentiates from other interfaces. + IsGraph_property_specificationContext() +} + +type Graph_property_specificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_property_specificationContext() *Graph_property_specificationContext { + var p = new(Graph_property_specificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_property_specification + return p +} + +func InitEmptyGraph_property_specificationContext(p *Graph_property_specificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_property_specification +} + +func (*Graph_property_specificationContext) IsGraph_property_specificationContext() {} + +func NewGraph_property_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_property_specificationContext { + var p = new(Graph_property_specificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_property_specification + + return p +} + +func (s *Graph_property_specificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_property_specificationContext) LC_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLC_BRACKET_SYMBOL, 0) +} + +func (s *Graph_property_specificationContext) AllGraph_property_name_and_value() []IGraph_property_name_and_valueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGraph_property_name_and_valueContext); ok { + len++ + } + } + + tst := make([]IGraph_property_name_and_valueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGraph_property_name_and_valueContext); ok { + tst[i] = t.(IGraph_property_name_and_valueContext) + i++ + } + } + + return tst +} + +func (s *Graph_property_specificationContext) Graph_property_name_and_value(i int) IGraph_property_name_and_valueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_property_name_and_valueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGraph_property_name_and_valueContext) +} + +func (s *Graph_property_specificationContext) RC_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRC_BRACKET_SYMBOL, 0) +} + +func (s *Graph_property_specificationContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Graph_property_specificationContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Graph_property_specificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_property_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_property_specificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_property_specification(s) + } +} + +func (s *Graph_property_specificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_property_specification(s) + } +} + +func (s *Graph_property_specificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_property_specification(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_property_specification() (localctx IGraph_property_specificationContext) { + localctx = NewGraph_property_specificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 74, GoogleSQLParserRULE_graph_property_specification) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1600) + p.Match(GoogleSQLParserLC_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1601) + p.Graph_property_name_and_value() + } + p.SetState(1606) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(1602) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1603) + p.Graph_property_name_and_value() + } + + p.SetState(1608) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1609) + p.Match(GoogleSQLParserRC_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_property_name_and_valueContext is an interface to support dynamic dispatch. +type IGraph_property_name_and_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + COLON_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + + // IsGraph_property_name_and_valueContext differentiates from other interfaces. + IsGraph_property_name_and_valueContext() +} + +type Graph_property_name_and_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_property_name_and_valueContext() *Graph_property_name_and_valueContext { + var p = new(Graph_property_name_and_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_property_name_and_value + return p +} + +func InitEmptyGraph_property_name_and_valueContext(p *Graph_property_name_and_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_property_name_and_value +} + +func (*Graph_property_name_and_valueContext) IsGraph_property_name_and_valueContext() {} + +func NewGraph_property_name_and_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_property_name_and_valueContext { + var p = new(Graph_property_name_and_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_property_name_and_value + + return p +} + +func (s *Graph_property_name_and_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_property_name_and_valueContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Graph_property_name_and_valueContext) COLON_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOLON_SYMBOL, 0) +} + +func (s *Graph_property_name_and_valueContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Graph_property_name_and_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_property_name_and_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_property_name_and_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_property_name_and_value(s) + } +} + +func (s *Graph_property_name_and_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_property_name_and_value(s) + } +} + +func (s *Graph_property_name_and_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_property_name_and_value(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_property_name_and_value() (localctx IGraph_property_name_and_valueContext) { + localctx = NewGraph_property_name_and_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 76, GoogleSQLParserRULE_graph_property_name_and_value) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1611) + p.Identifier() + } + { + p.SetState(1612) + p.Match(GoogleSQLParserCOLON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1613) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_is_label_expressionContext is an interface to support dynamic dispatch. +type IOpt_is_label_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IS_SYMBOL() antlr.TerminalNode + Label_expression() ILabel_expressionContext + COLON_SYMBOL() antlr.TerminalNode + + // IsOpt_is_label_expressionContext differentiates from other interfaces. + IsOpt_is_label_expressionContext() +} + +type Opt_is_label_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_is_label_expressionContext() *Opt_is_label_expressionContext { + var p = new(Opt_is_label_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_is_label_expression + return p +} + +func InitEmptyOpt_is_label_expressionContext(p *Opt_is_label_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_is_label_expression +} + +func (*Opt_is_label_expressionContext) IsOpt_is_label_expressionContext() {} + +func NewOpt_is_label_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_is_label_expressionContext { + var p = new(Opt_is_label_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_is_label_expression + + return p +} + +func (s *Opt_is_label_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_is_label_expressionContext) IS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIS_SYMBOL, 0) +} + +func (s *Opt_is_label_expressionContext) Label_expression() ILabel_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_expressionContext) +} + +func (s *Opt_is_label_expressionContext) COLON_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOLON_SYMBOL, 0) +} + +func (s *Opt_is_label_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_is_label_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_is_label_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_is_label_expression(s) + } +} + +func (s *Opt_is_label_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_is_label_expression(s) + } +} + +func (s *Opt_is_label_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_is_label_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_is_label_expression() (localctx IOpt_is_label_expressionContext) { + localctx = NewOpt_is_label_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 78, GoogleSQLParserRULE_opt_is_label_expression) + p.SetState(1619) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserIS_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1615) + p.Match(GoogleSQLParserIS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1616) + p.label_expression(0) + } + + case GoogleSQLParserCOLON_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1617) + p.Match(GoogleSQLParserCOLON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1618) + p.label_expression(0) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILabel_expressionContext is an interface to support dynamic dispatch. +type ILabel_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Label_primary() ILabel_primaryContext + EXCLAMATION_OPERATOR() antlr.TerminalNode + AllLabel_expression() []ILabel_expressionContext + Label_expression(i int) ILabel_expressionContext + BIT_AND_SYMBOL() antlr.TerminalNode + STROKE_SYMBOL() antlr.TerminalNode + + // IsLabel_expressionContext differentiates from other interfaces. + IsLabel_expressionContext() +} + +type Label_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLabel_expressionContext() *Label_expressionContext { + var p = new(Label_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_label_expression + return p +} + +func InitEmptyLabel_expressionContext(p *Label_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_label_expression +} + +func (*Label_expressionContext) IsLabel_expressionContext() {} + +func NewLabel_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Label_expressionContext { + var p = new(Label_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_label_expression + + return p +} + +func (s *Label_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Label_expressionContext) Label_primary() ILabel_primaryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_primaryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_primaryContext) +} + +func (s *Label_expressionContext) EXCLAMATION_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXCLAMATION_OPERATOR, 0) +} + +func (s *Label_expressionContext) AllLabel_expression() []ILabel_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILabel_expressionContext); ok { + len++ + } + } + + tst := make([]ILabel_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILabel_expressionContext); ok { + tst[i] = t.(ILabel_expressionContext) + i++ + } + } + + return tst +} + +func (s *Label_expressionContext) Label_expression(i int) ILabel_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILabel_expressionContext) +} + +func (s *Label_expressionContext) BIT_AND_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBIT_AND_SYMBOL, 0) +} + +func (s *Label_expressionContext) STROKE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTROKE_SYMBOL, 0) +} + +func (s *Label_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Label_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Label_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterLabel_expression(s) + } +} + +func (s *Label_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitLabel_expression(s) + } +} + +func (s *Label_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitLabel_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Label_expression() (localctx ILabel_expressionContext) { + return p.label_expression(0) +} + +func (p *GoogleSQLParser) label_expression(_p int) (localctx ILabel_expressionContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewLabel_expressionContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx ILabel_expressionContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 80 + p.EnterRecursionRule(localctx, 80, GoogleSQLParserRULE_label_expression, _p) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(1625) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserMODULO_OPERATOR, GoogleSQLParserLR_BRACKET_SYMBOL, GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + { + p.SetState(1622) + p.Label_primary() + } + + case GoogleSQLParserEXCLAMATION_OPERATOR: + { + p.SetState(1623) + p.Match(GoogleSQLParserEXCLAMATION_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1624) + p.label_expression(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(1635) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 54, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + p.SetState(1633) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 53, p.GetParserRuleContext()) { + case 1: + localctx = NewLabel_expressionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_label_expression) + p.SetState(1627) + + if !(p.Precpred(p.GetParserRuleContext(), 3)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", "")) + goto errorExit + } + { + p.SetState(1628) + p.Match(GoogleSQLParserBIT_AND_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1629) + p.label_expression(4) + } + + case 2: + localctx = NewLabel_expressionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_label_expression) + p.SetState(1630) + + if !(p.Precpred(p.GetParserRuleContext(), 2)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) + goto errorExit + } + { + p.SetState(1631) + p.Match(GoogleSQLParserSTROKE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1632) + p.label_expression(3) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(1637) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 54, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILabel_primaryContext is an interface to support dynamic dispatch. +type ILabel_primaryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + MODULO_OPERATOR() antlr.TerminalNode + Parenthesized_label_expression() IParenthesized_label_expressionContext + + // IsLabel_primaryContext differentiates from other interfaces. + IsLabel_primaryContext() +} + +type Label_primaryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLabel_primaryContext() *Label_primaryContext { + var p = new(Label_primaryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_label_primary + return p +} + +func InitEmptyLabel_primaryContext(p *Label_primaryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_label_primary +} + +func (*Label_primaryContext) IsLabel_primaryContext() {} + +func NewLabel_primaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Label_primaryContext { + var p = new(Label_primaryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_label_primary + + return p +} + +func (s *Label_primaryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Label_primaryContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Label_primaryContext) MODULO_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMODULO_OPERATOR, 0) +} + +func (s *Label_primaryContext) Parenthesized_label_expression() IParenthesized_label_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesized_label_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParenthesized_label_expressionContext) +} + +func (s *Label_primaryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Label_primaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Label_primaryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterLabel_primary(s) + } +} + +func (s *Label_primaryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitLabel_primary(s) + } +} + +func (s *Label_primaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitLabel_primary(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Label_primary() (localctx ILabel_primaryContext) { + localctx = NewLabel_primaryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 82, GoogleSQLParserRULE_label_primary) + p.SetState(1641) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1638) + p.Identifier() + } + + case GoogleSQLParserMODULO_OPERATOR: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1639) + p.Match(GoogleSQLParserMODULO_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserLR_BRACKET_SYMBOL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1640) + p.Parenthesized_label_expression() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParenthesized_label_expressionContext is an interface to support dynamic dispatch. +type IParenthesized_label_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + Label_expression() ILabel_expressionContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsParenthesized_label_expressionContext differentiates from other interfaces. + IsParenthesized_label_expressionContext() +} + +type Parenthesized_label_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParenthesized_label_expressionContext() *Parenthesized_label_expressionContext { + var p = new(Parenthesized_label_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_parenthesized_label_expression + return p +} + +func InitEmptyParenthesized_label_expressionContext(p *Parenthesized_label_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_parenthesized_label_expression +} + +func (*Parenthesized_label_expressionContext) IsParenthesized_label_expressionContext() {} + +func NewParenthesized_label_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Parenthesized_label_expressionContext { + var p = new(Parenthesized_label_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_parenthesized_label_expression + + return p +} + +func (s *Parenthesized_label_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Parenthesized_label_expressionContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Parenthesized_label_expressionContext) Label_expression() ILabel_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_expressionContext) +} + +func (s *Parenthesized_label_expressionContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Parenthesized_label_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Parenthesized_label_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Parenthesized_label_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterParenthesized_label_expression(s) + } +} + +func (s *Parenthesized_label_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitParenthesized_label_expression(s) + } +} + +func (s *Parenthesized_label_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitParenthesized_label_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Parenthesized_label_expression() (localctx IParenthesized_label_expressionContext) { + localctx = NewParenthesized_label_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 84, GoogleSQLParserRULE_parenthesized_label_expression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1643) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1644) + p.label_expression(0) + } + { + p.SetState(1645) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_graph_element_identifierContext is an interface to support dynamic dispatch. +type IOpt_graph_element_identifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Graph_identifier() IGraph_identifierContext + + // IsOpt_graph_element_identifierContext differentiates from other interfaces. + IsOpt_graph_element_identifierContext() +} + +type Opt_graph_element_identifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_graph_element_identifierContext() *Opt_graph_element_identifierContext { + var p = new(Opt_graph_element_identifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_graph_element_identifier + return p +} + +func InitEmptyOpt_graph_element_identifierContext(p *Opt_graph_element_identifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_graph_element_identifier +} + +func (*Opt_graph_element_identifierContext) IsOpt_graph_element_identifierContext() {} + +func NewOpt_graph_element_identifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_graph_element_identifierContext { + var p = new(Opt_graph_element_identifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_graph_element_identifier + + return p +} + +func (s *Opt_graph_element_identifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_graph_element_identifierContext) Graph_identifier() IGraph_identifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_identifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_identifierContext) +} + +func (s *Opt_graph_element_identifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_graph_element_identifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_graph_element_identifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_graph_element_identifier(s) + } +} + +func (s *Opt_graph_element_identifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_graph_element_identifier(s) + } +} + +func (s *Opt_graph_element_identifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_graph_element_identifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_graph_element_identifier() (localctx IOpt_graph_element_identifierContext) { + localctx = NewOpt_graph_element_identifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 86, GoogleSQLParserRULE_opt_graph_element_identifier) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1647) + p.Graph_identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_graph_path_mode_prefixContext is an interface to support dynamic dispatch. +type IOpt_graph_path_mode_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Opt_graph_path_mode() IOpt_graph_path_modeContext + Path_or_paths() IPath_or_pathsContext + + // IsOpt_graph_path_mode_prefixContext differentiates from other interfaces. + IsOpt_graph_path_mode_prefixContext() +} + +type Opt_graph_path_mode_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_graph_path_mode_prefixContext() *Opt_graph_path_mode_prefixContext { + var p = new(Opt_graph_path_mode_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_graph_path_mode_prefix + return p +} + +func InitEmptyOpt_graph_path_mode_prefixContext(p *Opt_graph_path_mode_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_graph_path_mode_prefix +} + +func (*Opt_graph_path_mode_prefixContext) IsOpt_graph_path_mode_prefixContext() {} + +func NewOpt_graph_path_mode_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_graph_path_mode_prefixContext { + var p = new(Opt_graph_path_mode_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_graph_path_mode_prefix + + return p +} + +func (s *Opt_graph_path_mode_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_graph_path_mode_prefixContext) Opt_graph_path_mode() IOpt_graph_path_modeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_graph_path_modeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_graph_path_modeContext) +} + +func (s *Opt_graph_path_mode_prefixContext) Path_or_paths() IPath_or_pathsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_or_pathsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_or_pathsContext) +} + +func (s *Opt_graph_path_mode_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_graph_path_mode_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_graph_path_mode_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_graph_path_mode_prefix(s) + } +} + +func (s *Opt_graph_path_mode_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_graph_path_mode_prefix(s) + } +} + +func (s *Opt_graph_path_mode_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_graph_path_mode_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_graph_path_mode_prefix() (localctx IOpt_graph_path_mode_prefixContext) { + localctx = NewOpt_graph_path_mode_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 88, GoogleSQLParserRULE_opt_graph_path_mode_prefix) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1649) + p.Opt_graph_path_mode() + } + p.SetState(1651) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserPATH_SYMBOL || _la == GoogleSQLParserPATHS_SYMBOL { + { + p.SetState(1650) + p.Path_or_paths() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPath_or_pathsContext is an interface to support dynamic dispatch. +type IPath_or_pathsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PATH_SYMBOL() antlr.TerminalNode + PATHS_SYMBOL() antlr.TerminalNode + + // IsPath_or_pathsContext differentiates from other interfaces. + IsPath_or_pathsContext() +} + +type Path_or_pathsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPath_or_pathsContext() *Path_or_pathsContext { + var p = new(Path_or_pathsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_path_or_paths + return p +} + +func InitEmptyPath_or_pathsContext(p *Path_or_pathsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_path_or_paths +} + +func (*Path_or_pathsContext) IsPath_or_pathsContext() {} + +func NewPath_or_pathsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Path_or_pathsContext { + var p = new(Path_or_pathsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_path_or_paths + + return p +} + +func (s *Path_or_pathsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Path_or_pathsContext) PATH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPATH_SYMBOL, 0) +} + +func (s *Path_or_pathsContext) PATHS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPATHS_SYMBOL, 0) +} + +func (s *Path_or_pathsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Path_or_pathsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Path_or_pathsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPath_or_paths(s) + } +} + +func (s *Path_or_pathsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPath_or_paths(s) + } +} + +func (s *Path_or_pathsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPath_or_paths(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Path_or_paths() (localctx IPath_or_pathsContext) { + localctx = NewPath_or_pathsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 90, GoogleSQLParserRULE_path_or_paths) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1653) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserPATH_SYMBOL || _la == GoogleSQLParserPATHS_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_graph_path_modeContext is an interface to support dynamic dispatch. +type IOpt_graph_path_modeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WALK_SYMBOL() antlr.TerminalNode + TRAIL_SYMBOL() antlr.TerminalNode + SIMPLE_SYMBOL() antlr.TerminalNode + ACYCLIC_SYMBOL() antlr.TerminalNode + + // IsOpt_graph_path_modeContext differentiates from other interfaces. + IsOpt_graph_path_modeContext() +} + +type Opt_graph_path_modeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_graph_path_modeContext() *Opt_graph_path_modeContext { + var p = new(Opt_graph_path_modeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_graph_path_mode + return p +} + +func InitEmptyOpt_graph_path_modeContext(p *Opt_graph_path_modeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_graph_path_mode +} + +func (*Opt_graph_path_modeContext) IsOpt_graph_path_modeContext() {} + +func NewOpt_graph_path_modeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_graph_path_modeContext { + var p = new(Opt_graph_path_modeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_graph_path_mode + + return p +} + +func (s *Opt_graph_path_modeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_graph_path_modeContext) WALK_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWALK_SYMBOL, 0) +} + +func (s *Opt_graph_path_modeContext) TRAIL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTRAIL_SYMBOL, 0) +} + +func (s *Opt_graph_path_modeContext) SIMPLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSIMPLE_SYMBOL, 0) +} + +func (s *Opt_graph_path_modeContext) ACYCLIC_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserACYCLIC_SYMBOL, 0) +} + +func (s *Opt_graph_path_modeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_graph_path_modeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_graph_path_modeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_graph_path_mode(s) + } +} + +func (s *Opt_graph_path_modeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_graph_path_mode(s) + } +} + +func (s *Opt_graph_path_modeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_graph_path_mode(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_graph_path_mode() (localctx IOpt_graph_path_modeContext) { + localctx = NewOpt_graph_path_modeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 92, GoogleSQLParserRULE_opt_graph_path_mode) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1655) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserSIMPLE_SYMBOL || ((int64((_la-359)) & ^0x3f) == 0 && ((int64(1)<<(_la-359))&7) != 0)) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_graph_search_prefixContext is an interface to support dynamic dispatch. +type IOpt_graph_search_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ANY_SYMBOL() antlr.TerminalNode + ALL_SYMBOL() antlr.TerminalNode + SHORTEST_SYMBOL() antlr.TerminalNode + + // IsOpt_graph_search_prefixContext differentiates from other interfaces. + IsOpt_graph_search_prefixContext() +} + +type Opt_graph_search_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_graph_search_prefixContext() *Opt_graph_search_prefixContext { + var p = new(Opt_graph_search_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_graph_search_prefix + return p +} + +func InitEmptyOpt_graph_search_prefixContext(p *Opt_graph_search_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_graph_search_prefix +} + +func (*Opt_graph_search_prefixContext) IsOpt_graph_search_prefixContext() {} + +func NewOpt_graph_search_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_graph_search_prefixContext { + var p = new(Opt_graph_search_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_graph_search_prefix + + return p +} + +func (s *Opt_graph_search_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_graph_search_prefixContext) ANY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserANY_SYMBOL, 0) +} + +func (s *Opt_graph_search_prefixContext) ALL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserALL_SYMBOL, 0) +} + +func (s *Opt_graph_search_prefixContext) SHORTEST_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSHORTEST_SYMBOL, 0) +} + +func (s *Opt_graph_search_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_graph_search_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_graph_search_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_graph_search_prefix(s) + } +} + +func (s *Opt_graph_search_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_graph_search_prefix(s) + } +} + +func (s *Opt_graph_search_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_graph_search_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_graph_search_prefix() (localctx IOpt_graph_search_prefixContext) { + localctx = NewOpt_graph_search_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 94, GoogleSQLParserRULE_opt_graph_search_prefix) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1657) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserALL_SYMBOL || _la == GoogleSQLParserANY_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(1659) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserSHORTEST_SYMBOL { + { + p.SetState(1658) + p.Match(GoogleSQLParserSHORTEST_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_path_variable_assignmentContext is an interface to support dynamic dispatch. +type IOpt_path_variable_assignmentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Graph_identifier() IGraph_identifierContext + EQUAL_OPERATOR() antlr.TerminalNode + + // IsOpt_path_variable_assignmentContext differentiates from other interfaces. + IsOpt_path_variable_assignmentContext() +} + +type Opt_path_variable_assignmentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_path_variable_assignmentContext() *Opt_path_variable_assignmentContext { + var p = new(Opt_path_variable_assignmentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_path_variable_assignment + return p +} + +func InitEmptyOpt_path_variable_assignmentContext(p *Opt_path_variable_assignmentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_path_variable_assignment +} + +func (*Opt_path_variable_assignmentContext) IsOpt_path_variable_assignmentContext() {} + +func NewOpt_path_variable_assignmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_path_variable_assignmentContext { + var p = new(Opt_path_variable_assignmentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_path_variable_assignment + + return p +} + +func (s *Opt_path_variable_assignmentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_path_variable_assignmentContext) Graph_identifier() IGraph_identifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_identifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_identifierContext) +} + +func (s *Opt_path_variable_assignmentContext) EQUAL_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEQUAL_OPERATOR, 0) +} + +func (s *Opt_path_variable_assignmentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_path_variable_assignmentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_path_variable_assignmentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_path_variable_assignment(s) + } +} + +func (s *Opt_path_variable_assignmentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_path_variable_assignment(s) + } +} + +func (s *Opt_path_variable_assignmentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_path_variable_assignment(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_path_variable_assignment() (localctx IOpt_path_variable_assignmentContext) { + localctx = NewOpt_path_variable_assignmentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 96, GoogleSQLParserRULE_opt_path_variable_assignment) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1661) + p.Graph_identifier() + } + { + p.SetState(1662) + p.Match(GoogleSQLParserEQUAL_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_identifierContext is an interface to support dynamic dispatch. +type IGraph_identifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Token_identifier() IToken_identifierContext + Common_keyword_as_identifier() ICommon_keyword_as_identifierContext + + // IsGraph_identifierContext differentiates from other interfaces. + IsGraph_identifierContext() +} + +type Graph_identifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_identifierContext() *Graph_identifierContext { + var p = new(Graph_identifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_identifier + return p +} + +func InitEmptyGraph_identifierContext(p *Graph_identifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_identifier +} + +func (*Graph_identifierContext) IsGraph_identifierContext() {} + +func NewGraph_identifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_identifierContext { + var p = new(Graph_identifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_identifier + + return p +} + +func (s *Graph_identifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_identifierContext) Token_identifier() IToken_identifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IToken_identifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IToken_identifierContext) +} + +func (s *Graph_identifierContext) Common_keyword_as_identifier() ICommon_keyword_as_identifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommon_keyword_as_identifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommon_keyword_as_identifierContext) +} + +func (s *Graph_identifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_identifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_identifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_identifier(s) + } +} + +func (s *Graph_identifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_identifier(s) + } +} + +func (s *Graph_identifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_identifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_identifier() (localctx IGraph_identifierContext) { + localctx = NewGraph_identifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 98, GoogleSQLParserRULE_graph_identifier) + p.SetState(1666) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1664) + p.Token_identifier() + } + + case GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1665) + p.Common_keyword_as_identifier() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_return_operatorContext is an interface to support dynamic dispatch. +type IGraph_return_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETURN_SYMBOL() antlr.TerminalNode + Graph_return_item_list() IGraph_return_item_listContext + Hint() IHintContext + All_or_distinct() IAll_or_distinctContext + Group_by_clause() IGroup_by_clauseContext + Graph_order_by_clause() IGraph_order_by_clauseContext + Graph_page_clause() IGraph_page_clauseContext + + // IsGraph_return_operatorContext differentiates from other interfaces. + IsGraph_return_operatorContext() +} + +type Graph_return_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_return_operatorContext() *Graph_return_operatorContext { + var p = new(Graph_return_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_return_operator + return p +} + +func InitEmptyGraph_return_operatorContext(p *Graph_return_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_return_operator +} + +func (*Graph_return_operatorContext) IsGraph_return_operatorContext() {} + +func NewGraph_return_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_return_operatorContext { + var p = new(Graph_return_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_return_operator + + return p +} + +func (s *Graph_return_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_return_operatorContext) RETURN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRETURN_SYMBOL, 0) +} + +func (s *Graph_return_operatorContext) Graph_return_item_list() IGraph_return_item_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_return_item_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_return_item_listContext) +} + +func (s *Graph_return_operatorContext) Hint() IHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Graph_return_operatorContext) All_or_distinct() IAll_or_distinctContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_or_distinctContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_or_distinctContext) +} + +func (s *Graph_return_operatorContext) Group_by_clause() IGroup_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGroup_by_clauseContext) +} + +func (s *Graph_return_operatorContext) Graph_order_by_clause() IGraph_order_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_order_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_order_by_clauseContext) +} + +func (s *Graph_return_operatorContext) Graph_page_clause() IGraph_page_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_page_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGraph_page_clauseContext) +} + +func (s *Graph_return_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_return_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_return_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_return_operator(s) + } +} + +func (s *Graph_return_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_return_operator(s) + } +} + +func (s *Graph_return_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_return_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_return_operator() (localctx IGraph_return_operatorContext) { + localctx = NewGraph_return_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 100, GoogleSQLParserRULE_graph_return_operator) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1668) + p.Match(GoogleSQLParserRETURN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1670) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 59, p.GetParserRuleContext()) == 1 { + { + p.SetState(1669) + p.Hint() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(1673) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserALL_SYMBOL || _la == GoogleSQLParserDISTINCT_SYMBOL { + { + p.SetState(1672) + p.All_or_distinct() + } + + } + { + p.SetState(1675) + p.Graph_return_item_list() + } + p.SetState(1677) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserGROUP_SYMBOL { + { + p.SetState(1676) + p.Group_by_clause() + } + + } + p.SetState(1680) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserORDER_SYMBOL { + { + p.SetState(1679) + p.Graph_order_by_clause() + } + + } + p.SetState(1683) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLIMIT_SYMBOL || _la == GoogleSQLParserOFFSET_SYMBOL || _la == GoogleSQLParserSKIP_SYMBOL { + { + p.SetState(1682) + p.Graph_page_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_page_clauseContext is an interface to support dynamic dispatch. +type IGraph_page_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OFFSET_SYMBOL() antlr.TerminalNode + AllPossibly_cast_int_literal_or_parameter() []IPossibly_cast_int_literal_or_parameterContext + Possibly_cast_int_literal_or_parameter(i int) IPossibly_cast_int_literal_or_parameterContext + LIMIT_SYMBOL() antlr.TerminalNode + SKIP_SYMBOL() antlr.TerminalNode + + // IsGraph_page_clauseContext differentiates from other interfaces. + IsGraph_page_clauseContext() +} + +type Graph_page_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_page_clauseContext() *Graph_page_clauseContext { + var p = new(Graph_page_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_page_clause + return p +} + +func InitEmptyGraph_page_clauseContext(p *Graph_page_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_page_clause +} + +func (*Graph_page_clauseContext) IsGraph_page_clauseContext() {} + +func NewGraph_page_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_page_clauseContext { + var p = new(Graph_page_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_page_clause + + return p +} + +func (s *Graph_page_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_page_clauseContext) OFFSET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOFFSET_SYMBOL, 0) +} + +func (s *Graph_page_clauseContext) AllPossibly_cast_int_literal_or_parameter() []IPossibly_cast_int_literal_or_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPossibly_cast_int_literal_or_parameterContext); ok { + len++ + } + } + + tst := make([]IPossibly_cast_int_literal_or_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPossibly_cast_int_literal_or_parameterContext); ok { + tst[i] = t.(IPossibly_cast_int_literal_or_parameterContext) + i++ + } + } + + return tst +} + +func (s *Graph_page_clauseContext) Possibly_cast_int_literal_or_parameter(i int) IPossibly_cast_int_literal_or_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPossibly_cast_int_literal_or_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPossibly_cast_int_literal_or_parameterContext) +} + +func (s *Graph_page_clauseContext) LIMIT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLIMIT_SYMBOL, 0) +} + +func (s *Graph_page_clauseContext) SKIP_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSKIP_SYMBOL, 0) +} + +func (s *Graph_page_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_page_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_page_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_page_clause(s) + } +} + +func (s *Graph_page_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_page_clause(s) + } +} + +func (s *Graph_page_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_page_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_page_clause() (localctx IGraph_page_clauseContext) { + localctx = NewGraph_page_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 102, GoogleSQLParserRULE_graph_page_clause) + p.SetState(1701) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 64, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1685) + p.Match(GoogleSQLParserOFFSET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1686) + p.Possibly_cast_int_literal_or_parameter() + } + { + p.SetState(1687) + p.Match(GoogleSQLParserLIMIT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1688) + p.Possibly_cast_int_literal_or_parameter() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1690) + p.Match(GoogleSQLParserSKIP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1691) + p.Possibly_cast_int_literal_or_parameter() + } + { + p.SetState(1692) + p.Match(GoogleSQLParserLIMIT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1693) + p.Possibly_cast_int_literal_or_parameter() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1695) + p.Match(GoogleSQLParserOFFSET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1696) + p.Possibly_cast_int_literal_or_parameter() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1697) + p.Match(GoogleSQLParserSKIP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1698) + p.Possibly_cast_int_literal_or_parameter() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1699) + p.Match(GoogleSQLParserLIMIT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1700) + p.Possibly_cast_int_literal_or_parameter() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_order_by_clauseContext is an interface to support dynamic dispatch. +type IGraph_order_by_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ORDER_SYMBOL() antlr.TerminalNode + BY_SYMBOL() antlr.TerminalNode + AllGraph_ordering_expression() []IGraph_ordering_expressionContext + Graph_ordering_expression(i int) IGraph_ordering_expressionContext + Hint() IHintContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsGraph_order_by_clauseContext differentiates from other interfaces. + IsGraph_order_by_clauseContext() +} + +type Graph_order_by_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_order_by_clauseContext() *Graph_order_by_clauseContext { + var p = new(Graph_order_by_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_order_by_clause + return p +} + +func InitEmptyGraph_order_by_clauseContext(p *Graph_order_by_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_order_by_clause +} + +func (*Graph_order_by_clauseContext) IsGraph_order_by_clauseContext() {} + +func NewGraph_order_by_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_order_by_clauseContext { + var p = new(Graph_order_by_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_order_by_clause + + return p +} + +func (s *Graph_order_by_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_order_by_clauseContext) ORDER_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserORDER_SYMBOL, 0) +} + +func (s *Graph_order_by_clauseContext) BY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBY_SYMBOL, 0) +} + +func (s *Graph_order_by_clauseContext) AllGraph_ordering_expression() []IGraph_ordering_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGraph_ordering_expressionContext); ok { + len++ + } + } + + tst := make([]IGraph_ordering_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGraph_ordering_expressionContext); ok { + tst[i] = t.(IGraph_ordering_expressionContext) + i++ + } + } + + return tst +} + +func (s *Graph_order_by_clauseContext) Graph_ordering_expression(i int) IGraph_ordering_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_ordering_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGraph_ordering_expressionContext) +} + +func (s *Graph_order_by_clauseContext) Hint() IHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Graph_order_by_clauseContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Graph_order_by_clauseContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Graph_order_by_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_order_by_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_order_by_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_order_by_clause(s) + } +} + +func (s *Graph_order_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_order_by_clause(s) + } +} + +func (s *Graph_order_by_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_order_by_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_order_by_clause() (localctx IGraph_order_by_clauseContext) { + localctx = NewGraph_order_by_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 104, GoogleSQLParserRULE_graph_order_by_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1703) + p.Match(GoogleSQLParserORDER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1705) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(1704) + p.Hint() + } + + } + { + p.SetState(1707) + p.Match(GoogleSQLParserBY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1708) + p.Graph_ordering_expression() + } + p.SetState(1713) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(1709) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1710) + p.Graph_ordering_expression() + } + + p.SetState(1715) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_ordering_expressionContext is an interface to support dynamic dispatch. +type IGraph_ordering_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + Collate_clause() ICollate_clauseContext + Opt_graph_asc_or_desc() IOpt_graph_asc_or_descContext + Null_order() INull_orderContext + + // IsGraph_ordering_expressionContext differentiates from other interfaces. + IsGraph_ordering_expressionContext() +} + +type Graph_ordering_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_ordering_expressionContext() *Graph_ordering_expressionContext { + var p = new(Graph_ordering_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_ordering_expression + return p +} + +func InitEmptyGraph_ordering_expressionContext(p *Graph_ordering_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_ordering_expression +} + +func (*Graph_ordering_expressionContext) IsGraph_ordering_expressionContext() {} + +func NewGraph_ordering_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_ordering_expressionContext { + var p = new(Graph_ordering_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_ordering_expression + + return p +} + +func (s *Graph_ordering_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_ordering_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Graph_ordering_expressionContext) Collate_clause() ICollate_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollate_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollate_clauseContext) +} + +func (s *Graph_ordering_expressionContext) Opt_graph_asc_or_desc() IOpt_graph_asc_or_descContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_graph_asc_or_descContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_graph_asc_or_descContext) +} + +func (s *Graph_ordering_expressionContext) Null_order() INull_orderContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INull_orderContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INull_orderContext) +} + +func (s *Graph_ordering_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_ordering_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_ordering_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_ordering_expression(s) + } +} + +func (s *Graph_ordering_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_ordering_expression(s) + } +} + +func (s *Graph_ordering_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_ordering_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_ordering_expression() (localctx IGraph_ordering_expressionContext) { + localctx = NewGraph_ordering_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 106, GoogleSQLParserRULE_graph_ordering_expression) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1716) + p.expression(0) + } + p.SetState(1718) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCOLLATE_SYMBOL { + { + p.SetState(1717) + p.Collate_clause() + } + + } + p.SetState(1721) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserASC_SYMBOL || _la == GoogleSQLParserDESC_SYMBOL || _la == GoogleSQLParserASCENDING_SYMBOL || _la == GoogleSQLParserDESCENDING_SYMBOL { + { + p.SetState(1720) + p.Opt_graph_asc_or_desc() + } + + } + p.SetState(1724) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserNULLS_SYMBOL { + { + p.SetState(1723) + p.Null_order() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_graph_asc_or_descContext is an interface to support dynamic dispatch. +type IOpt_graph_asc_or_descContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Asc_or_desc() IAsc_or_descContext + ASCENDING_SYMBOL() antlr.TerminalNode + DESCENDING_SYMBOL() antlr.TerminalNode + + // IsOpt_graph_asc_or_descContext differentiates from other interfaces. + IsOpt_graph_asc_or_descContext() +} + +type Opt_graph_asc_or_descContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_graph_asc_or_descContext() *Opt_graph_asc_or_descContext { + var p = new(Opt_graph_asc_or_descContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_graph_asc_or_desc + return p +} + +func InitEmptyOpt_graph_asc_or_descContext(p *Opt_graph_asc_or_descContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_graph_asc_or_desc +} + +func (*Opt_graph_asc_or_descContext) IsOpt_graph_asc_or_descContext() {} + +func NewOpt_graph_asc_or_descContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_graph_asc_or_descContext { + var p = new(Opt_graph_asc_or_descContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_graph_asc_or_desc + + return p +} + +func (s *Opt_graph_asc_or_descContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_graph_asc_or_descContext) Asc_or_desc() IAsc_or_descContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAsc_or_descContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAsc_or_descContext) +} + +func (s *Opt_graph_asc_or_descContext) ASCENDING_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserASCENDING_SYMBOL, 0) +} + +func (s *Opt_graph_asc_or_descContext) DESCENDING_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDESCENDING_SYMBOL, 0) +} + +func (s *Opt_graph_asc_or_descContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_graph_asc_or_descContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_graph_asc_or_descContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_graph_asc_or_desc(s) + } +} + +func (s *Opt_graph_asc_or_descContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_graph_asc_or_desc(s) + } +} + +func (s *Opt_graph_asc_or_descContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_graph_asc_or_desc(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_graph_asc_or_desc() (localctx IOpt_graph_asc_or_descContext) { + localctx = NewOpt_graph_asc_or_descContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 108, GoogleSQLParserRULE_opt_graph_asc_or_desc) + p.SetState(1729) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserASC_SYMBOL, GoogleSQLParserDESC_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1726) + p.Asc_or_desc() + } + + case GoogleSQLParserASCENDING_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1727) + p.Match(GoogleSQLParserASCENDING_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserDESCENDING_SYMBOL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1728) + p.Match(GoogleSQLParserDESCENDING_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_return_item_listContext is an interface to support dynamic dispatch. +type IGraph_return_item_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllGraph_return_item() []IGraph_return_itemContext + Graph_return_item(i int) IGraph_return_itemContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsGraph_return_item_listContext differentiates from other interfaces. + IsGraph_return_item_listContext() +} + +type Graph_return_item_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_return_item_listContext() *Graph_return_item_listContext { + var p = new(Graph_return_item_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_return_item_list + return p +} + +func InitEmptyGraph_return_item_listContext(p *Graph_return_item_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_return_item_list +} + +func (*Graph_return_item_listContext) IsGraph_return_item_listContext() {} + +func NewGraph_return_item_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_return_item_listContext { + var p = new(Graph_return_item_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_return_item_list + + return p +} + +func (s *Graph_return_item_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_return_item_listContext) AllGraph_return_item() []IGraph_return_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGraph_return_itemContext); ok { + len++ + } + } + + tst := make([]IGraph_return_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGraph_return_itemContext); ok { + tst[i] = t.(IGraph_return_itemContext) + i++ + } + } + + return tst +} + +func (s *Graph_return_item_listContext) Graph_return_item(i int) IGraph_return_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGraph_return_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGraph_return_itemContext) +} + +func (s *Graph_return_item_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Graph_return_item_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Graph_return_item_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_return_item_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_return_item_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_return_item_list(s) + } +} + +func (s *Graph_return_item_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_return_item_list(s) + } +} + +func (s *Graph_return_item_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_return_item_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_return_item_list() (localctx IGraph_return_item_listContext) { + localctx = NewGraph_return_item_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 110, GoogleSQLParserRULE_graph_return_item_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1731) + p.Graph_return_item() + } + p.SetState(1736) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(1732) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1733) + p.Graph_return_item() + } + + p.SetState(1738) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGraph_return_itemContext is an interface to support dynamic dispatch. +type IGraph_return_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + AS_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + MULTIPLY_OPERATOR() antlr.TerminalNode + + // IsGraph_return_itemContext differentiates from other interfaces. + IsGraph_return_itemContext() +} + +type Graph_return_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGraph_return_itemContext() *Graph_return_itemContext { + var p = new(Graph_return_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_return_item + return p +} + +func InitEmptyGraph_return_itemContext(p *Graph_return_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_graph_return_item +} + +func (*Graph_return_itemContext) IsGraph_return_itemContext() {} + +func NewGraph_return_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Graph_return_itemContext { + var p = new(Graph_return_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_graph_return_item + + return p +} + +func (s *Graph_return_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Graph_return_itemContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Graph_return_itemContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Graph_return_itemContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Graph_return_itemContext) MULTIPLY_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMULTIPLY_OPERATOR, 0) +} + +func (s *Graph_return_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Graph_return_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Graph_return_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGraph_return_item(s) + } +} + +func (s *Graph_return_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGraph_return_item(s) + } +} + +func (s *Graph_return_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGraph_return_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Graph_return_item() (localctx IGraph_return_itemContext) { + localctx = NewGraph_return_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 112, GoogleSQLParserRULE_graph_return_item) + var _la int + + p.SetState(1745) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserPLUS_OPERATOR, GoogleSQLParserMINUS_OPERATOR, GoogleSQLParserBITWISE_NOT_OPERATOR, GoogleSQLParserRC_BRACKET_SYMBOL, GoogleSQLParserLR_BRACKET_SYMBOL, GoogleSQLParserLS_BRACKET_SYMBOL, GoogleSQLParserQUESTION_SYMBOL, GoogleSQLParserAT_SYMBOL, GoogleSQLParserATAT_SYMBOL, GoogleSQLParserSTRING_LITERAL, GoogleSQLParserBYTES_LITERAL, GoogleSQLParserFLOATING_POINT_LITERAL, GoogleSQLParserINTEGER_LITERAL, GoogleSQLParserARRAY_SYMBOL, GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserLEFT_SYMBOL, GoogleSQLParserNULL_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserRIGHT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSTRUCT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserWITH_SYMBOL, GoogleSQLParserTRUE_SYMBOL, GoogleSQLParserFALSE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserNOT_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserRANGE_SYMBOL, GoogleSQLParserINTERVAL_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserNEW_SYMBOL, GoogleSQLParserCASE_SYMBOL, GoogleSQLParserCAST_SYMBOL, GoogleSQLParserEXTRACT_SYMBOL, GoogleSQLParserCOLLATE_SYMBOL, GoogleSQLParserIF_SYMBOL, GoogleSQLParserGROUPING_SYMBOL, GoogleSQLParserEXISTS_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1739) + p.expression(0) + } + p.SetState(1742) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(1740) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1741) + p.Identifier() + } + + } + + case GoogleSQLParserMULTIPLY_OPERATOR: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1744) + p.Match(GoogleSQLParserMULTIPLY_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUndrop_statementContext is an interface to support dynamic dispatch. +type IUndrop_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNDROP_SYMBOL() antlr.TerminalNode + Schema_object_kind() ISchema_object_kindContext + Path_expression() IPath_expressionContext + Opt_if_not_exists() IOpt_if_not_existsContext + Opt_at_system_time() IOpt_at_system_timeContext + Opt_options_list() IOpt_options_listContext + + // IsUndrop_statementContext differentiates from other interfaces. + IsUndrop_statementContext() +} + +type Undrop_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUndrop_statementContext() *Undrop_statementContext { + var p = new(Undrop_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_undrop_statement + return p +} + +func InitEmptyUndrop_statementContext(p *Undrop_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_undrop_statement +} + +func (*Undrop_statementContext) IsUndrop_statementContext() {} + +func NewUndrop_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Undrop_statementContext { + var p = new(Undrop_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_undrop_statement + + return p +} + +func (s *Undrop_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Undrop_statementContext) UNDROP_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUNDROP_SYMBOL, 0) +} + +func (s *Undrop_statementContext) Schema_object_kind() ISchema_object_kindContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_object_kindContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_object_kindContext) +} + +func (s *Undrop_statementContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Undrop_statementContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *Undrop_statementContext) Opt_at_system_time() IOpt_at_system_timeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_at_system_timeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_at_system_timeContext) +} + +func (s *Undrop_statementContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Undrop_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Undrop_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Undrop_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterUndrop_statement(s) + } +} + +func (s *Undrop_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitUndrop_statement(s) + } +} + +func (s *Undrop_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitUndrop_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Undrop_statement() (localctx IUndrop_statementContext) { + localctx = NewUndrop_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 114, GoogleSQLParserRULE_undrop_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1747) + p.Match(GoogleSQLParserUNDROP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1748) + p.Schema_object_kind() + } + p.SetState(1750) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(1749) + p.Opt_if_not_exists() + } + + } + { + p.SetState(1752) + p.Path_expression() + } + p.SetState(1754) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserFOR_SYMBOL { + { + p.SetState(1753) + p.Opt_at_system_time() + } + + } + p.SetState(1757) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(1756) + p.Opt_options_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModule_statementContext is an interface to support dynamic dispatch. +type IModule_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODULE_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + Opt_options_list() IOpt_options_listContext + + // IsModule_statementContext differentiates from other interfaces. + IsModule_statementContext() +} + +type Module_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModule_statementContext() *Module_statementContext { + var p = new(Module_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_module_statement + return p +} + +func InitEmptyModule_statementContext(p *Module_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_module_statement +} + +func (*Module_statementContext) IsModule_statementContext() {} + +func NewModule_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Module_statementContext { + var p = new(Module_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_module_statement + + return p +} + +func (s *Module_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Module_statementContext) MODULE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMODULE_SYMBOL, 0) +} + +func (s *Module_statementContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Module_statementContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Module_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Module_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Module_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterModule_statement(s) + } +} + +func (s *Module_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitModule_statement(s) + } +} + +func (s *Module_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitModule_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Module_statement() (localctx IModule_statementContext) { + localctx = NewModule_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 116, GoogleSQLParserRULE_module_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1759) + p.Match(GoogleSQLParserMODULE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1760) + p.Path_expression() + } + p.SetState(1762) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(1761) + p.Opt_options_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IImport_statementContext is an interface to support dynamic dispatch. +type IImport_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IMPORT_SYMBOL() antlr.TerminalNode + Import_type() IImport_typeContext + Path_expression_or_string() IPath_expression_or_stringContext + Opt_as_or_into_alias() IOpt_as_or_into_aliasContext + Opt_options_list() IOpt_options_listContext + + // IsImport_statementContext differentiates from other interfaces. + IsImport_statementContext() +} + +type Import_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImport_statementContext() *Import_statementContext { + var p = new(Import_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_import_statement + return p +} + +func InitEmptyImport_statementContext(p *Import_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_import_statement +} + +func (*Import_statementContext) IsImport_statementContext() {} + +func NewImport_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Import_statementContext { + var p = new(Import_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_import_statement + + return p +} + +func (s *Import_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Import_statementContext) IMPORT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIMPORT_SYMBOL, 0) +} + +func (s *Import_statementContext) Import_type() IImport_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImport_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImport_typeContext) +} + +func (s *Import_statementContext) Path_expression_or_string() IPath_expression_or_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expression_or_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expression_or_stringContext) +} + +func (s *Import_statementContext) Opt_as_or_into_alias() IOpt_as_or_into_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_as_or_into_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_as_or_into_aliasContext) +} + +func (s *Import_statementContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Import_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Import_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Import_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterImport_statement(s) + } +} + +func (s *Import_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitImport_statement(s) + } +} + +func (s *Import_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitImport_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Import_statement() (localctx IImport_statementContext) { + localctx = NewImport_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 118, GoogleSQLParserRULE_import_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1764) + p.Match(GoogleSQLParserIMPORT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1765) + p.Import_type() + } + { + p.SetState(1766) + p.Path_expression_or_string() + } + p.SetState(1768) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL || _la == GoogleSQLParserINTO_SYMBOL { + { + p.SetState(1767) + p.Opt_as_or_into_alias() + } + + } + p.SetState(1771) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(1770) + p.Opt_options_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_as_or_into_aliasContext is an interface to support dynamic dispatch. +type IOpt_as_or_into_aliasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + AS_SYMBOL() antlr.TerminalNode + INTO_SYMBOL() antlr.TerminalNode + + // IsOpt_as_or_into_aliasContext differentiates from other interfaces. + IsOpt_as_or_into_aliasContext() +} + +type Opt_as_or_into_aliasContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_as_or_into_aliasContext() *Opt_as_or_into_aliasContext { + var p = new(Opt_as_or_into_aliasContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_as_or_into_alias + return p +} + +func InitEmptyOpt_as_or_into_aliasContext(p *Opt_as_or_into_aliasContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_as_or_into_alias +} + +func (*Opt_as_or_into_aliasContext) IsOpt_as_or_into_aliasContext() {} + +func NewOpt_as_or_into_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_as_or_into_aliasContext { + var p = new(Opt_as_or_into_aliasContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_as_or_into_alias + + return p +} + +func (s *Opt_as_or_into_aliasContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_as_or_into_aliasContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Opt_as_or_into_aliasContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Opt_as_or_into_aliasContext) INTO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINTO_SYMBOL, 0) +} + +func (s *Opt_as_or_into_aliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_as_or_into_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_as_or_into_aliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_as_or_into_alias(s) + } +} + +func (s *Opt_as_or_into_aliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_as_or_into_alias(s) + } +} + +func (s *Opt_as_or_into_aliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_as_or_into_alias(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_as_or_into_alias() (localctx IOpt_as_or_into_aliasContext) { + localctx = NewOpt_as_or_into_aliasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 120, GoogleSQLParserRULE_opt_as_or_into_alias) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1773) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserAS_SYMBOL || _la == GoogleSQLParserINTO_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1774) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPath_expression_or_stringContext is an interface to support dynamic dispatch. +type IPath_expression_or_stringContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Path_expression() IPath_expressionContext + String_literal() IString_literalContext + + // IsPath_expression_or_stringContext differentiates from other interfaces. + IsPath_expression_or_stringContext() +} + +type Path_expression_or_stringContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPath_expression_or_stringContext() *Path_expression_or_stringContext { + var p = new(Path_expression_or_stringContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_path_expression_or_string + return p +} + +func InitEmptyPath_expression_or_stringContext(p *Path_expression_or_stringContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_path_expression_or_string +} + +func (*Path_expression_or_stringContext) IsPath_expression_or_stringContext() {} + +func NewPath_expression_or_stringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Path_expression_or_stringContext { + var p = new(Path_expression_or_stringContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_path_expression_or_string + + return p +} + +func (s *Path_expression_or_stringContext) GetParser() antlr.Parser { return s.parser } + +func (s *Path_expression_or_stringContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Path_expression_or_stringContext) String_literal() IString_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_literalContext) +} + +func (s *Path_expression_or_stringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Path_expression_or_stringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Path_expression_or_stringContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPath_expression_or_string(s) + } +} + +func (s *Path_expression_or_stringContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPath_expression_or_string(s) + } +} + +func (s *Path_expression_or_stringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPath_expression_or_string(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Path_expression_or_string() (localctx IPath_expression_or_stringContext) { + localctx = NewPath_expression_or_stringContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 122, GoogleSQLParserRULE_path_expression_or_string) + p.SetState(1778) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1776) + p.Path_expression() + } + + case GoogleSQLParserSTRING_LITERAL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1777) + p.string_literal(0) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IImport_typeContext is an interface to support dynamic dispatch. +type IImport_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODULE_SYMBOL() antlr.TerminalNode + PROTO_SYMBOL() antlr.TerminalNode + + // IsImport_typeContext differentiates from other interfaces. + IsImport_typeContext() +} + +type Import_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImport_typeContext() *Import_typeContext { + var p = new(Import_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_import_type + return p +} + +func InitEmptyImport_typeContext(p *Import_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_import_type +} + +func (*Import_typeContext) IsImport_typeContext() {} + +func NewImport_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Import_typeContext { + var p = new(Import_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_import_type + + return p +} + +func (s *Import_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Import_typeContext) MODULE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMODULE_SYMBOL, 0) +} + +func (s *Import_typeContext) PROTO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPROTO_SYMBOL, 0) +} + +func (s *Import_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Import_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Import_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterImport_type(s) + } +} + +func (s *Import_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitImport_type(s) + } +} + +func (s *Import_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitImport_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Import_type() (localctx IImport_typeContext) { + localctx = NewImport_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 124, GoogleSQLParserRULE_import_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1780) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserMODULE_SYMBOL || _la == GoogleSQLParserPROTO_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICall_statementContext is an interface to support dynamic dispatch. +type ICall_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CALL_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + LR_BRACKET_SYMBOL() antlr.TerminalNode + RR_BRACKET_SYMBOL() antlr.TerminalNode + AllTvf_argument() []ITvf_argumentContext + Tvf_argument(i int) ITvf_argumentContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsCall_statementContext differentiates from other interfaces. + IsCall_statementContext() +} + +type Call_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCall_statementContext() *Call_statementContext { + var p = new(Call_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_call_statement + return p +} + +func InitEmptyCall_statementContext(p *Call_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_call_statement +} + +func (*Call_statementContext) IsCall_statementContext() {} + +func NewCall_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Call_statementContext { + var p = new(Call_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_call_statement + + return p +} + +func (s *Call_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Call_statementContext) CALL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCALL_SYMBOL, 0) +} + +func (s *Call_statementContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Call_statementContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Call_statementContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Call_statementContext) AllTvf_argument() []ITvf_argumentContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITvf_argumentContext); ok { + len++ + } + } + + tst := make([]ITvf_argumentContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITvf_argumentContext); ok { + tst[i] = t.(ITvf_argumentContext) + i++ + } + } + + return tst +} + +func (s *Call_statementContext) Tvf_argument(i int) ITvf_argumentContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITvf_argumentContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITvf_argumentContext) +} + +func (s *Call_statementContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Call_statementContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Call_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Call_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Call_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCall_statement(s) + } +} + +func (s *Call_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCall_statement(s) + } +} + +func (s *Call_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCall_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Call_statement() (localctx ICall_statementContext) { + localctx = NewCall_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 126, GoogleSQLParserRULE_call_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1782) + p.Match(GoogleSQLParserCALL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1783) + p.Path_expression() + } + { + p.SetState(1784) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1793) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&126153626265603072) != 0) || ((int64((_la-74)) & ^0x3f) == 0 && ((int64(1)<<(_la-74))&-825137378743) != 0) || ((int64((_la-138)) & ^0x3f) == 0 && ((int64(1)<<(_la-138))&-1) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-36028797018963969) != 0) || ((int64((_la-266)) & ^0x3f) == 0 && ((int64(1)<<(_la-266))&1068373114879) != 0) || ((int64((_la-332)) & ^0x3f) == 0 && ((int64(1)<<(_la-332))&8573149441) != 0) { + { + p.SetState(1785) + p.Tvf_argument() + } + p.SetState(1790) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(1786) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1787) + p.Tvf_argument() + } + + p.SetState(1792) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(1795) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_statementContext is an interface to support dynamic dispatch. +type IDrop_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP_SYMBOL() antlr.TerminalNode + PRIVILEGE_SYMBOL() antlr.TerminalNode + RESTRICTION_SYMBOL() antlr.TerminalNode + AllON_SYMBOL() []antlr.TerminalNode + ON_SYMBOL(i int) antlr.TerminalNode + Privilege_list() IPrivilege_listContext + Identifier() IIdentifierContext + Path_expression() IPath_expressionContext + Opt_if_exists() IOpt_if_existsContext + ROW_SYMBOL() antlr.TerminalNode + ACCESS_SYMBOL() antlr.TerminalNode + POLICY_SYMBOL() antlr.TerminalNode + On_path_expression() IOn_path_expressionContext + Index_type() IIndex_typeContext + INDEX_SYMBOL() antlr.TerminalNode + Table_or_table_function() ITable_or_table_functionContext + Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext + Opt_function_parameters() IOpt_function_parametersContext + SNAPSHOT_SYMBOL() antlr.TerminalNode + TABLE_SYMBOL() antlr.TerminalNode + Generic_entity_type() IGeneric_entity_typeContext + Schema_object_kind() ISchema_object_kindContext + Opt_drop_mode() IOpt_drop_modeContext + + // IsDrop_statementContext differentiates from other interfaces. + IsDrop_statementContext() +} + +type Drop_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_statementContext() *Drop_statementContext { + var p = new(Drop_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_drop_statement + return p +} + +func InitEmptyDrop_statementContext(p *Drop_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_drop_statement +} + +func (*Drop_statementContext) IsDrop_statementContext() {} + +func NewDrop_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_statementContext { + var p = new(Drop_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_drop_statement + + return p +} + +func (s *Drop_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_statementContext) DROP_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDROP_SYMBOL, 0) +} + +func (s *Drop_statementContext) PRIVILEGE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPRIVILEGE_SYMBOL, 0) +} + +func (s *Drop_statementContext) RESTRICTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRESTRICTION_SYMBOL, 0) +} + +func (s *Drop_statementContext) AllON_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserON_SYMBOL) +} + +func (s *Drop_statementContext) ON_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserON_SYMBOL, i) +} + +func (s *Drop_statementContext) Privilege_list() IPrivilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrivilege_listContext) +} + +func (s *Drop_statementContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Drop_statementContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Drop_statementContext) Opt_if_exists() IOpt_if_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_existsContext) +} + +func (s *Drop_statementContext) ROW_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserROW_SYMBOL, 0) +} + +func (s *Drop_statementContext) ACCESS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserACCESS_SYMBOL, 0) +} + +func (s *Drop_statementContext) POLICY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPOLICY_SYMBOL, 0) +} + +func (s *Drop_statementContext) On_path_expression() IOn_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_path_expressionContext) +} + +func (s *Drop_statementContext) Index_type() IIndex_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_typeContext) +} + +func (s *Drop_statementContext) INDEX_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINDEX_SYMBOL, 0) +} + +func (s *Drop_statementContext) Table_or_table_function() ITable_or_table_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_or_table_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_or_table_functionContext) +} + +func (s *Drop_statementContext) Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_dashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_dashed_path_expressionContext) +} + +func (s *Drop_statementContext) Opt_function_parameters() IOpt_function_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_function_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_function_parametersContext) +} + +func (s *Drop_statementContext) SNAPSHOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSNAPSHOT_SYMBOL, 0) +} + +func (s *Drop_statementContext) TABLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTABLE_SYMBOL, 0) +} + +func (s *Drop_statementContext) Generic_entity_type() IGeneric_entity_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneric_entity_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneric_entity_typeContext) +} + +func (s *Drop_statementContext) Schema_object_kind() ISchema_object_kindContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_object_kindContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_object_kindContext) +} + +func (s *Drop_statementContext) Opt_drop_mode() IOpt_drop_modeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_modeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_modeContext) +} + +func (s *Drop_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterDrop_statement(s) + } +} + +func (s *Drop_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitDrop_statement(s) + } +} + +func (s *Drop_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitDrop_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Drop_statement() (localctx IDrop_statementContext) { + localctx = NewDrop_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 128, GoogleSQLParserRULE_drop_statement) + var _la int + + p.SetState(1864) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 94, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1797) + p.Match(GoogleSQLParserDROP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1798) + p.Match(GoogleSQLParserPRIVILEGE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1799) + p.Match(GoogleSQLParserRESTRICTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1801) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(1800) + p.Opt_if_exists() + } + + } + { + p.SetState(1803) + p.Match(GoogleSQLParserON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1804) + p.Privilege_list() + } + { + p.SetState(1805) + p.Match(GoogleSQLParserON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1806) + p.Identifier() + } + { + p.SetState(1807) + p.Path_expression() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1809) + p.Match(GoogleSQLParserDROP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1810) + p.Match(GoogleSQLParserROW_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1811) + p.Match(GoogleSQLParserACCESS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1812) + p.Match(GoogleSQLParserPOLICY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1814) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(1813) + p.Opt_if_exists() + } + + } + { + p.SetState(1816) + p.Identifier() + } + { + p.SetState(1817) + p.On_path_expression() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1819) + p.Match(GoogleSQLParserDROP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1820) + p.Index_type() + } + { + p.SetState(1821) + p.Match(GoogleSQLParserINDEX_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1823) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(1822) + p.Opt_if_exists() + } + + } + { + p.SetState(1825) + p.Path_expression() + } + p.SetState(1827) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserON_SYMBOL { + { + p.SetState(1826) + p.On_path_expression() + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1829) + p.Match(GoogleSQLParserDROP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1830) + p.Table_or_table_function() + } + p.SetState(1832) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(1831) + p.Opt_if_exists() + } + + } + { + p.SetState(1834) + p.Maybe_dashed_path_expression() + } + p.SetState(1836) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL { + { + p.SetState(1835) + p.Opt_function_parameters() + } + + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1838) + p.Match(GoogleSQLParserDROP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1839) + p.Match(GoogleSQLParserSNAPSHOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1840) + p.Match(GoogleSQLParserTABLE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1842) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(1841) + p.Opt_if_exists() + } + + } + { + p.SetState(1844) + p.Maybe_dashed_path_expression() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(1845) + p.Match(GoogleSQLParserDROP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1846) + p.Generic_entity_type() + } + p.SetState(1848) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(1847) + p.Opt_if_exists() + } + + } + { + p.SetState(1850) + p.Path_expression() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(1852) + p.Match(GoogleSQLParserDROP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1853) + p.Schema_object_kind() + } + p.SetState(1855) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(1854) + p.Opt_if_exists() + } + + } + { + p.SetState(1857) + p.Path_expression() + } + p.SetState(1859) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL { + { + p.SetState(1858) + p.Opt_function_parameters() + } + + } + p.SetState(1862) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCASCADE_SYMBOL || _la == GoogleSQLParserRESTRICT_SYMBOL { + { + p.SetState(1861) + p.Opt_drop_mode() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_drop_modeContext is an interface to support dynamic dispatch. +type IOpt_drop_modeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RESTRICT_SYMBOL() antlr.TerminalNode + CASCADE_SYMBOL() antlr.TerminalNode + + // IsOpt_drop_modeContext differentiates from other interfaces. + IsOpt_drop_modeContext() +} + +type Opt_drop_modeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_drop_modeContext() *Opt_drop_modeContext { + var p = new(Opt_drop_modeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_drop_mode + return p +} + +func InitEmptyOpt_drop_modeContext(p *Opt_drop_modeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_drop_mode +} + +func (*Opt_drop_modeContext) IsOpt_drop_modeContext() {} + +func NewOpt_drop_modeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_drop_modeContext { + var p = new(Opt_drop_modeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_drop_mode + + return p +} + +func (s *Opt_drop_modeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_drop_modeContext) RESTRICT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRESTRICT_SYMBOL, 0) +} + +func (s *Opt_drop_modeContext) CASCADE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCASCADE_SYMBOL, 0) +} + +func (s *Opt_drop_modeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_drop_modeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_drop_modeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_drop_mode(s) + } +} + +func (s *Opt_drop_modeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_drop_mode(s) + } +} + +func (s *Opt_drop_modeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_drop_mode(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_drop_mode() (localctx IOpt_drop_modeContext) { + localctx = NewOpt_drop_modeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 130, GoogleSQLParserRULE_opt_drop_mode) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1866) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserCASCADE_SYMBOL || _la == GoogleSQLParserRESTRICT_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_all_row_access_policies_statementContext is an interface to support dynamic dispatch. +type IDrop_all_row_access_policies_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP_SYMBOL() antlr.TerminalNode + ALL_SYMBOL() antlr.TerminalNode + ROW_SYMBOL() antlr.TerminalNode + POLICIES_SYMBOL() antlr.TerminalNode + ON_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + ACCESS_SYMBOL() antlr.TerminalNode + + // IsDrop_all_row_access_policies_statementContext differentiates from other interfaces. + IsDrop_all_row_access_policies_statementContext() +} + +type Drop_all_row_access_policies_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_all_row_access_policies_statementContext() *Drop_all_row_access_policies_statementContext { + var p = new(Drop_all_row_access_policies_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_drop_all_row_access_policies_statement + return p +} + +func InitEmptyDrop_all_row_access_policies_statementContext(p *Drop_all_row_access_policies_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_drop_all_row_access_policies_statement +} + +func (*Drop_all_row_access_policies_statementContext) IsDrop_all_row_access_policies_statementContext() { +} + +func NewDrop_all_row_access_policies_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_all_row_access_policies_statementContext { + var p = new(Drop_all_row_access_policies_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_drop_all_row_access_policies_statement + + return p +} + +func (s *Drop_all_row_access_policies_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_all_row_access_policies_statementContext) DROP_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDROP_SYMBOL, 0) +} + +func (s *Drop_all_row_access_policies_statementContext) ALL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserALL_SYMBOL, 0) +} + +func (s *Drop_all_row_access_policies_statementContext) ROW_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserROW_SYMBOL, 0) +} + +func (s *Drop_all_row_access_policies_statementContext) POLICIES_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPOLICIES_SYMBOL, 0) +} + +func (s *Drop_all_row_access_policies_statementContext) ON_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserON_SYMBOL, 0) +} + +func (s *Drop_all_row_access_policies_statementContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Drop_all_row_access_policies_statementContext) ACCESS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserACCESS_SYMBOL, 0) +} + +func (s *Drop_all_row_access_policies_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_all_row_access_policies_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_all_row_access_policies_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterDrop_all_row_access_policies_statement(s) + } +} + +func (s *Drop_all_row_access_policies_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitDrop_all_row_access_policies_statement(s) + } +} + +func (s *Drop_all_row_access_policies_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitDrop_all_row_access_policies_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Drop_all_row_access_policies_statement() (localctx IDrop_all_row_access_policies_statementContext) { + localctx = NewDrop_all_row_access_policies_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 132, GoogleSQLParserRULE_drop_all_row_access_policies_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1868) + p.Match(GoogleSQLParserDROP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1869) + p.Match(GoogleSQLParserALL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1870) + p.Match(GoogleSQLParserROW_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1872) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserACCESS_SYMBOL { + { + p.SetState(1871) + p.Match(GoogleSQLParserACCESS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1874) + p.Match(GoogleSQLParserPOLICIES_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1875) + p.Match(GoogleSQLParserON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1876) + p.Path_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_statementContext is an interface to support dynamic dispatch. +type IShow_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW_SYMBOL() antlr.TerminalNode + Show_target() IShow_targetContext + Opt_from_path_expression() IOpt_from_path_expressionContext + Opt_like_string_literal() IOpt_like_string_literalContext + + // IsShow_statementContext differentiates from other interfaces. + IsShow_statementContext() +} + +type Show_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_statementContext() *Show_statementContext { + var p = new(Show_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_show_statement + return p +} + +func InitEmptyShow_statementContext(p *Show_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_show_statement +} + +func (*Show_statementContext) IsShow_statementContext() {} + +func NewShow_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_statementContext { + var p = new(Show_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_show_statement + + return p +} + +func (s *Show_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_statementContext) SHOW_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSHOW_SYMBOL, 0) +} + +func (s *Show_statementContext) Show_target() IShow_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_targetContext) +} + +func (s *Show_statementContext) Opt_from_path_expression() IOpt_from_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_from_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_from_path_expressionContext) +} + +func (s *Show_statementContext) Opt_like_string_literal() IOpt_like_string_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_like_string_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_like_string_literalContext) +} + +func (s *Show_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterShow_statement(s) + } +} + +func (s *Show_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitShow_statement(s) + } +} + +func (s *Show_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitShow_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Show_statement() (localctx IShow_statementContext) { + localctx = NewShow_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 134, GoogleSQLParserRULE_show_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1878) + p.Match(GoogleSQLParserSHOW_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1879) + p.Show_target() + } + p.SetState(1881) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserFROM_SYMBOL { + { + p.SetState(1880) + p.Opt_from_path_expression() + } + + } + p.SetState(1884) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLIKE_SYMBOL { + { + p.SetState(1883) + p.Opt_like_string_literal() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_like_string_literalContext is an interface to support dynamic dispatch. +type IOpt_like_string_literalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LIKE_SYMBOL() antlr.TerminalNode + String_literal() IString_literalContext + + // IsOpt_like_string_literalContext differentiates from other interfaces. + IsOpt_like_string_literalContext() +} + +type Opt_like_string_literalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_like_string_literalContext() *Opt_like_string_literalContext { + var p = new(Opt_like_string_literalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_like_string_literal + return p +} + +func InitEmptyOpt_like_string_literalContext(p *Opt_like_string_literalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_like_string_literal +} + +func (*Opt_like_string_literalContext) IsOpt_like_string_literalContext() {} + +func NewOpt_like_string_literalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_like_string_literalContext { + var p = new(Opt_like_string_literalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_like_string_literal + + return p +} + +func (s *Opt_like_string_literalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_like_string_literalContext) LIKE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLIKE_SYMBOL, 0) +} + +func (s *Opt_like_string_literalContext) String_literal() IString_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_literalContext) +} + +func (s *Opt_like_string_literalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_like_string_literalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_like_string_literalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_like_string_literal(s) + } +} + +func (s *Opt_like_string_literalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_like_string_literal(s) + } +} + +func (s *Opt_like_string_literalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_like_string_literal(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_like_string_literal() (localctx IOpt_like_string_literalContext) { + localctx = NewOpt_like_string_literalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 136, GoogleSQLParserRULE_opt_like_string_literal) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1886) + p.Match(GoogleSQLParserLIKE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1887) + p.string_literal(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_targetContext is an interface to support dynamic dispatch. +type IShow_targetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MATERIALIZED_SYMBOL() antlr.TerminalNode + VIEWS_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsShow_targetContext differentiates from other interfaces. + IsShow_targetContext() +} + +type Show_targetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_targetContext() *Show_targetContext { + var p = new(Show_targetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_show_target + return p +} + +func InitEmptyShow_targetContext(p *Show_targetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_show_target +} + +func (*Show_targetContext) IsShow_targetContext() {} + +func NewShow_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_targetContext { + var p = new(Show_targetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_show_target + + return p +} + +func (s *Show_targetContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_targetContext) MATERIALIZED_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMATERIALIZED_SYMBOL, 0) +} + +func (s *Show_targetContext) VIEWS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserVIEWS_SYMBOL, 0) +} + +func (s *Show_targetContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Show_targetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_targetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterShow_target(s) + } +} + +func (s *Show_targetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitShow_target(s) + } +} + +func (s *Show_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitShow_target(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Show_target() (localctx IShow_targetContext) { + localctx = NewShow_targetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 138, GoogleSQLParserRULE_show_target) + p.SetState(1892) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 98, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1889) + p.Match(GoogleSQLParserMATERIALIZED_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1890) + p.Match(GoogleSQLParserVIEWS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1891) + p.Identifier() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRename_statementContext is an interface to support dynamic dispatch. +type IRename_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RENAME_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + AllPath_expression() []IPath_expressionContext + Path_expression(i int) IPath_expressionContext + TO_SYMBOL() antlr.TerminalNode + + // IsRename_statementContext differentiates from other interfaces. + IsRename_statementContext() +} + +type Rename_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRename_statementContext() *Rename_statementContext { + var p = new(Rename_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_rename_statement + return p +} + +func InitEmptyRename_statementContext(p *Rename_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_rename_statement +} + +func (*Rename_statementContext) IsRename_statementContext() {} + +func NewRename_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rename_statementContext { + var p = new(Rename_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_rename_statement + + return p +} + +func (s *Rename_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rename_statementContext) RENAME_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRENAME_SYMBOL, 0) +} + +func (s *Rename_statementContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Rename_statementContext) AllPath_expression() []IPath_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPath_expressionContext); ok { + len++ + } + } + + tst := make([]IPath_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPath_expressionContext); ok { + tst[i] = t.(IPath_expressionContext) + i++ + } + } + + return tst +} + +func (s *Rename_statementContext) Path_expression(i int) IPath_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Rename_statementContext) TO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTO_SYMBOL, 0) +} + +func (s *Rename_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rename_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rename_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterRename_statement(s) + } +} + +func (s *Rename_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitRename_statement(s) + } +} + +func (s *Rename_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitRename_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Rename_statement() (localctx IRename_statementContext) { + localctx = NewRename_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 140, GoogleSQLParserRULE_rename_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1894) + p.Match(GoogleSQLParserRENAME_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1895) + p.Identifier() + } + { + p.SetState(1896) + p.Path_expression() + } + { + p.SetState(1897) + p.Match(GoogleSQLParserTO_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1898) + p.Path_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevoke_statementContext is an interface to support dynamic dispatch. +type IRevoke_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE_SYMBOL() antlr.TerminalNode + Privileges() IPrivilegesContext + ON_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + FROM_SYMBOL() antlr.TerminalNode + Grantee_list() IGrantee_listContext + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + + // IsRevoke_statementContext differentiates from other interfaces. + IsRevoke_statementContext() +} + +type Revoke_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_statementContext() *Revoke_statementContext { + var p = new(Revoke_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_revoke_statement + return p +} + +func InitEmptyRevoke_statementContext(p *Revoke_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_revoke_statement +} + +func (*Revoke_statementContext) IsRevoke_statementContext() {} + +func NewRevoke_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_statementContext { + var p = new(Revoke_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_revoke_statement + + return p +} + +func (s *Revoke_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_statementContext) REVOKE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREVOKE_SYMBOL, 0) +} + +func (s *Revoke_statementContext) Privileges() IPrivilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrivilegesContext) +} + +func (s *Revoke_statementContext) ON_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserON_SYMBOL, 0) +} + +func (s *Revoke_statementContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Revoke_statementContext) FROM_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFROM_SYMBOL, 0) +} + +func (s *Revoke_statementContext) Grantee_list() IGrantee_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_listContext) +} + +func (s *Revoke_statementContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Revoke_statementContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Revoke_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterRevoke_statement(s) + } +} + +func (s *Revoke_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitRevoke_statement(s) + } +} + +func (s *Revoke_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitRevoke_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Revoke_statement() (localctx IRevoke_statementContext) { + localctx = NewRevoke_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 142, GoogleSQLParserRULE_revoke_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1900) + p.Match(GoogleSQLParserREVOKE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1901) + p.Privileges() + } + { + p.SetState(1902) + p.Match(GoogleSQLParserON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1907) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 100, p.GetParserRuleContext()) == 1 { + { + p.SetState(1903) + p.Identifier() + } + p.SetState(1905) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 99, p.GetParserRuleContext()) == 1 { + { + p.SetState(1904) + p.Identifier() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1909) + p.Path_expression() + } + { + p.SetState(1910) + p.Match(GoogleSQLParserFROM_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1911) + p.Grantee_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrant_statementContext is an interface to support dynamic dispatch. +type IGrant_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANT_SYMBOL() antlr.TerminalNode + Privileges() IPrivilegesContext + ON_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + TO_SYMBOL() antlr.TerminalNode + Grantee_list() IGrantee_listContext + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + + // IsGrant_statementContext differentiates from other interfaces. + IsGrant_statementContext() +} + +type Grant_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_statementContext() *Grant_statementContext { + var p = new(Grant_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_grant_statement + return p +} + +func InitEmptyGrant_statementContext(p *Grant_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_grant_statement +} + +func (*Grant_statementContext) IsGrant_statementContext() {} + +func NewGrant_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_statementContext { + var p = new(Grant_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_grant_statement + + return p +} + +func (s *Grant_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_statementContext) GRANT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserGRANT_SYMBOL, 0) +} + +func (s *Grant_statementContext) Privileges() IPrivilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrivilegesContext) +} + +func (s *Grant_statementContext) ON_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserON_SYMBOL, 0) +} + +func (s *Grant_statementContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Grant_statementContext) TO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTO_SYMBOL, 0) +} + +func (s *Grant_statementContext) Grantee_list() IGrantee_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_listContext) +} + +func (s *Grant_statementContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Grant_statementContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Grant_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGrant_statement(s) + } +} + +func (s *Grant_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGrant_statement(s) + } +} + +func (s *Grant_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGrant_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Grant_statement() (localctx IGrant_statementContext) { + localctx = NewGrant_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 144, GoogleSQLParserRULE_grant_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1913) + p.Match(GoogleSQLParserGRANT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1914) + p.Privileges() + } + { + p.SetState(1915) + p.Match(GoogleSQLParserON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1920) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 102, p.GetParserRuleContext()) == 1 { + { + p.SetState(1916) + p.Identifier() + } + p.SetState(1918) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 101, p.GetParserRuleContext()) == 1 { + { + p.SetState(1917) + p.Identifier() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1922) + p.Path_expression() + } + { + p.SetState(1923) + p.Match(GoogleSQLParserTO_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1924) + p.Grantee_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrivilegesContext is an interface to support dynamic dispatch. +type IPrivilegesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL_SYMBOL() antlr.TerminalNode + PRIVILEGES_SYMBOL() antlr.TerminalNode + Privilege_list() IPrivilege_listContext + + // IsPrivilegesContext differentiates from other interfaces. + IsPrivilegesContext() +} + +type PrivilegesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrivilegesContext() *PrivilegesContext { + var p = new(PrivilegesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_privileges + return p +} + +func InitEmptyPrivilegesContext(p *PrivilegesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_privileges +} + +func (*PrivilegesContext) IsPrivilegesContext() {} + +func NewPrivilegesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrivilegesContext { + var p = new(PrivilegesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_privileges + + return p +} + +func (s *PrivilegesContext) GetParser() antlr.Parser { return s.parser } + +func (s *PrivilegesContext) ALL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserALL_SYMBOL, 0) +} + +func (s *PrivilegesContext) PRIVILEGES_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPRIVILEGES_SYMBOL, 0) +} + +func (s *PrivilegesContext) Privilege_list() IPrivilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrivilege_listContext) +} + +func (s *PrivilegesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PrivilegesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PrivilegesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPrivileges(s) + } +} + +func (s *PrivilegesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPrivileges(s) + } +} + +func (s *PrivilegesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPrivileges(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Privileges() (localctx IPrivilegesContext) { + localctx = NewPrivilegesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 146, GoogleSQLParserRULE_privileges) + var _la int + + p.SetState(1931) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserALL_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1926) + p.Match(GoogleSQLParserALL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1928) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserPRIVILEGES_SYMBOL { + { + p.SetState(1927) + p.Match(GoogleSQLParserPRIVILEGES_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSELECT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1930) + p.Privilege_list() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExport_metadata_statementContext is an interface to support dynamic dispatch. +type IExport_metadata_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXPORT_SYMBOL() antlr.TerminalNode + Table_or_table_function() ITable_or_table_functionContext + METADATA_SYMBOL() antlr.TerminalNode + FROM_SYMBOL() antlr.TerminalNode + Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext + With_connection_clause() IWith_connection_clauseContext + Opt_options_list() IOpt_options_listContext + + // IsExport_metadata_statementContext differentiates from other interfaces. + IsExport_metadata_statementContext() +} + +type Export_metadata_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExport_metadata_statementContext() *Export_metadata_statementContext { + var p = new(Export_metadata_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_export_metadata_statement + return p +} + +func InitEmptyExport_metadata_statementContext(p *Export_metadata_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_export_metadata_statement +} + +func (*Export_metadata_statementContext) IsExport_metadata_statementContext() {} + +func NewExport_metadata_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Export_metadata_statementContext { + var p = new(Export_metadata_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_export_metadata_statement + + return p +} + +func (s *Export_metadata_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Export_metadata_statementContext) EXPORT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXPORT_SYMBOL, 0) +} + +func (s *Export_metadata_statementContext) Table_or_table_function() ITable_or_table_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_or_table_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_or_table_functionContext) +} + +func (s *Export_metadata_statementContext) METADATA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMETADATA_SYMBOL, 0) +} + +func (s *Export_metadata_statementContext) FROM_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFROM_SYMBOL, 0) +} + +func (s *Export_metadata_statementContext) Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_dashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_dashed_path_expressionContext) +} + +func (s *Export_metadata_statementContext) With_connection_clause() IWith_connection_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_connection_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_connection_clauseContext) +} + +func (s *Export_metadata_statementContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Export_metadata_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Export_metadata_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Export_metadata_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterExport_metadata_statement(s) + } +} + +func (s *Export_metadata_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitExport_metadata_statement(s) + } +} + +func (s *Export_metadata_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitExport_metadata_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Export_metadata_statement() (localctx IExport_metadata_statementContext) { + localctx = NewExport_metadata_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 148, GoogleSQLParserRULE_export_metadata_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1933) + p.Match(GoogleSQLParserEXPORT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1934) + p.Table_or_table_function() + } + { + p.SetState(1935) + p.Match(GoogleSQLParserMETADATA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1936) + p.Match(GoogleSQLParserFROM_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1937) + p.Maybe_dashed_path_expression() + } + p.SetState(1939) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWITH_SYMBOL { + { + p.SetState(1938) + p.With_connection_clause() + } + + } + p.SetState(1942) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(1941) + p.Opt_options_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExport_model_statementContext is an interface to support dynamic dispatch. +type IExport_model_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXPORT_SYMBOL() antlr.TerminalNode + MODEL_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + With_connection_clause() IWith_connection_clauseContext + Opt_options_list() IOpt_options_listContext + + // IsExport_model_statementContext differentiates from other interfaces. + IsExport_model_statementContext() +} + +type Export_model_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExport_model_statementContext() *Export_model_statementContext { + var p = new(Export_model_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_export_model_statement + return p +} + +func InitEmptyExport_model_statementContext(p *Export_model_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_export_model_statement +} + +func (*Export_model_statementContext) IsExport_model_statementContext() {} + +func NewExport_model_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Export_model_statementContext { + var p = new(Export_model_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_export_model_statement + + return p +} + +func (s *Export_model_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Export_model_statementContext) EXPORT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXPORT_SYMBOL, 0) +} + +func (s *Export_model_statementContext) MODEL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMODEL_SYMBOL, 0) +} + +func (s *Export_model_statementContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Export_model_statementContext) With_connection_clause() IWith_connection_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_connection_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_connection_clauseContext) +} + +func (s *Export_model_statementContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Export_model_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Export_model_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Export_model_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterExport_model_statement(s) + } +} + +func (s *Export_model_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitExport_model_statement(s) + } +} + +func (s *Export_model_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitExport_model_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Export_model_statement() (localctx IExport_model_statementContext) { + localctx = NewExport_model_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 150, GoogleSQLParserRULE_export_model_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1944) + p.Match(GoogleSQLParserEXPORT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1945) + p.Match(GoogleSQLParserMODEL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1946) + p.Path_expression() + } + p.SetState(1948) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWITH_SYMBOL { + { + p.SetState(1947) + p.With_connection_clause() + } + + } + p.SetState(1951) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(1950) + p.Opt_options_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExport_data_statementContext is an interface to support dynamic dispatch. +type IExport_data_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Export_data_no_query() IExport_data_no_queryContext + As_query() IAs_queryContext + + // IsExport_data_statementContext differentiates from other interfaces. + IsExport_data_statementContext() +} + +type Export_data_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExport_data_statementContext() *Export_data_statementContext { + var p = new(Export_data_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_export_data_statement + return p +} + +func InitEmptyExport_data_statementContext(p *Export_data_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_export_data_statement +} + +func (*Export_data_statementContext) IsExport_data_statementContext() {} + +func NewExport_data_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Export_data_statementContext { + var p = new(Export_data_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_export_data_statement + + return p +} + +func (s *Export_data_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Export_data_statementContext) Export_data_no_query() IExport_data_no_queryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExport_data_no_queryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExport_data_no_queryContext) +} + +func (s *Export_data_statementContext) As_query() IAs_queryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_queryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_queryContext) +} + +func (s *Export_data_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Export_data_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Export_data_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterExport_data_statement(s) + } +} + +func (s *Export_data_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitExport_data_statement(s) + } +} + +func (s *Export_data_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitExport_data_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Export_data_statement() (localctx IExport_data_statementContext) { + localctx = NewExport_data_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 152, GoogleSQLParserRULE_export_data_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1953) + p.Export_data_no_query() + } + { + p.SetState(1954) + p.As_query() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExport_data_no_queryContext is an interface to support dynamic dispatch. +type IExport_data_no_queryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXPORT_SYMBOL() antlr.TerminalNode + DATA_SYMBOL() antlr.TerminalNode + With_connection_clause() IWith_connection_clauseContext + Opt_options_list() IOpt_options_listContext + + // IsExport_data_no_queryContext differentiates from other interfaces. + IsExport_data_no_queryContext() +} + +type Export_data_no_queryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExport_data_no_queryContext() *Export_data_no_queryContext { + var p = new(Export_data_no_queryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_export_data_no_query + return p +} + +func InitEmptyExport_data_no_queryContext(p *Export_data_no_queryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_export_data_no_query +} + +func (*Export_data_no_queryContext) IsExport_data_no_queryContext() {} + +func NewExport_data_no_queryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Export_data_no_queryContext { + var p = new(Export_data_no_queryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_export_data_no_query + + return p +} + +func (s *Export_data_no_queryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Export_data_no_queryContext) EXPORT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXPORT_SYMBOL, 0) +} + +func (s *Export_data_no_queryContext) DATA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDATA_SYMBOL, 0) +} + +func (s *Export_data_no_queryContext) With_connection_clause() IWith_connection_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_connection_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_connection_clauseContext) +} + +func (s *Export_data_no_queryContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Export_data_no_queryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Export_data_no_queryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Export_data_no_queryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterExport_data_no_query(s) + } +} + +func (s *Export_data_no_queryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitExport_data_no_query(s) + } +} + +func (s *Export_data_no_queryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitExport_data_no_query(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Export_data_no_query() (localctx IExport_data_no_queryContext) { + localctx = NewExport_data_no_queryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 154, GoogleSQLParserRULE_export_data_no_query) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1956) + p.Match(GoogleSQLParserEXPORT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1957) + p.Match(GoogleSQLParserDATA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1959) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWITH_SYMBOL { + { + p.SetState(1958) + p.With_connection_clause() + } + + } + p.SetState(1962) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(1961) + p.Opt_options_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExplain_statementContext is an interface to support dynamic dispatch. +type IExplain_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXPLAIN_SYMBOL() antlr.TerminalNode + Unterminated_sql_statement() IUnterminated_sql_statementContext + + // IsExplain_statementContext differentiates from other interfaces. + IsExplain_statementContext() +} + +type Explain_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExplain_statementContext() *Explain_statementContext { + var p = new(Explain_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_explain_statement + return p +} + +func InitEmptyExplain_statementContext(p *Explain_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_explain_statement +} + +func (*Explain_statementContext) IsExplain_statementContext() {} + +func NewExplain_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Explain_statementContext { + var p = new(Explain_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_explain_statement + + return p +} + +func (s *Explain_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Explain_statementContext) EXPLAIN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXPLAIN_SYMBOL, 0) +} + +func (s *Explain_statementContext) Unterminated_sql_statement() IUnterminated_sql_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnterminated_sql_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnterminated_sql_statementContext) +} + +func (s *Explain_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Explain_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Explain_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterExplain_statement(s) + } +} + +func (s *Explain_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitExplain_statement(s) + } +} + +func (s *Explain_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitExplain_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Explain_statement() (localctx IExplain_statementContext) { + localctx = NewExplain_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 156, GoogleSQLParserRULE_explain_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1964) + p.Match(GoogleSQLParserEXPLAIN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1965) + p.Unterminated_sql_statement() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExecute_immediateContext is an interface to support dynamic dispatch. +type IExecute_immediateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXECUTE_SYMBOL() antlr.TerminalNode + IMMEDIATE_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + Opt_execute_into_clause() IOpt_execute_into_clauseContext + Opt_execute_using_clause() IOpt_execute_using_clauseContext + + // IsExecute_immediateContext differentiates from other interfaces. + IsExecute_immediateContext() +} + +type Execute_immediateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExecute_immediateContext() *Execute_immediateContext { + var p = new(Execute_immediateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_execute_immediate + return p +} + +func InitEmptyExecute_immediateContext(p *Execute_immediateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_execute_immediate +} + +func (*Execute_immediateContext) IsExecute_immediateContext() {} + +func NewExecute_immediateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Execute_immediateContext { + var p = new(Execute_immediateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_execute_immediate + + return p +} + +func (s *Execute_immediateContext) GetParser() antlr.Parser { return s.parser } + +func (s *Execute_immediateContext) EXECUTE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXECUTE_SYMBOL, 0) +} + +func (s *Execute_immediateContext) IMMEDIATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIMMEDIATE_SYMBOL, 0) +} + +func (s *Execute_immediateContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Execute_immediateContext) Opt_execute_into_clause() IOpt_execute_into_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_execute_into_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_execute_into_clauseContext) +} + +func (s *Execute_immediateContext) Opt_execute_using_clause() IOpt_execute_using_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_execute_using_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_execute_using_clauseContext) +} + +func (s *Execute_immediateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Execute_immediateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Execute_immediateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterExecute_immediate(s) + } +} + +func (s *Execute_immediateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitExecute_immediate(s) + } +} + +func (s *Execute_immediateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitExecute_immediate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Execute_immediate() (localctx IExecute_immediateContext) { + localctx = NewExecute_immediateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 158, GoogleSQLParserRULE_execute_immediate) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1967) + p.Match(GoogleSQLParserEXECUTE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1968) + p.Match(GoogleSQLParserIMMEDIATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1969) + p.expression(0) + } + p.SetState(1971) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserINTO_SYMBOL { + { + p.SetState(1970) + p.Opt_execute_into_clause() + } + + } + p.SetState(1974) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserUSING_SYMBOL { + { + p.SetState(1973) + p.Opt_execute_using_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_execute_into_clauseContext is an interface to support dynamic dispatch. +type IOpt_execute_into_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INTO_SYMBOL() antlr.TerminalNode + Identifier_list() IIdentifier_listContext + + // IsOpt_execute_into_clauseContext differentiates from other interfaces. + IsOpt_execute_into_clauseContext() +} + +type Opt_execute_into_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_execute_into_clauseContext() *Opt_execute_into_clauseContext { + var p = new(Opt_execute_into_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_execute_into_clause + return p +} + +func InitEmptyOpt_execute_into_clauseContext(p *Opt_execute_into_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_execute_into_clause +} + +func (*Opt_execute_into_clauseContext) IsOpt_execute_into_clauseContext() {} + +func NewOpt_execute_into_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_execute_into_clauseContext { + var p = new(Opt_execute_into_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_execute_into_clause + + return p +} + +func (s *Opt_execute_into_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_execute_into_clauseContext) INTO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINTO_SYMBOL, 0) +} + +func (s *Opt_execute_into_clauseContext) Identifier_list() IIdentifier_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifier_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifier_listContext) +} + +func (s *Opt_execute_into_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_execute_into_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_execute_into_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_execute_into_clause(s) + } +} + +func (s *Opt_execute_into_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_execute_into_clause(s) + } +} + +func (s *Opt_execute_into_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_execute_into_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_execute_into_clause() (localctx IOpt_execute_into_clauseContext) { + localctx = NewOpt_execute_into_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 160, GoogleSQLParserRULE_opt_execute_into_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1976) + p.Match(GoogleSQLParserINTO_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1977) + p.Identifier_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_execute_using_clauseContext is an interface to support dynamic dispatch. +type IOpt_execute_using_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING_SYMBOL() antlr.TerminalNode + Execute_using_argument_list() IExecute_using_argument_listContext + + // IsOpt_execute_using_clauseContext differentiates from other interfaces. + IsOpt_execute_using_clauseContext() +} + +type Opt_execute_using_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_execute_using_clauseContext() *Opt_execute_using_clauseContext { + var p = new(Opt_execute_using_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_execute_using_clause + return p +} + +func InitEmptyOpt_execute_using_clauseContext(p *Opt_execute_using_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_execute_using_clause +} + +func (*Opt_execute_using_clauseContext) IsOpt_execute_using_clauseContext() {} + +func NewOpt_execute_using_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_execute_using_clauseContext { + var p = new(Opt_execute_using_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_execute_using_clause + + return p +} + +func (s *Opt_execute_using_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_execute_using_clauseContext) USING_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUSING_SYMBOL, 0) +} + +func (s *Opt_execute_using_clauseContext) Execute_using_argument_list() IExecute_using_argument_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_using_argument_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExecute_using_argument_listContext) +} + +func (s *Opt_execute_using_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_execute_using_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_execute_using_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_execute_using_clause(s) + } +} + +func (s *Opt_execute_using_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_execute_using_clause(s) + } +} + +func (s *Opt_execute_using_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_execute_using_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_execute_using_clause() (localctx IOpt_execute_using_clauseContext) { + localctx = NewOpt_execute_using_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 162, GoogleSQLParserRULE_opt_execute_using_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1979) + p.Match(GoogleSQLParserUSING_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1980) + p.Execute_using_argument_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExecute_using_argument_listContext is an interface to support dynamic dispatch. +type IExecute_using_argument_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllExecute_using_argument() []IExecute_using_argumentContext + Execute_using_argument(i int) IExecute_using_argumentContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsExecute_using_argument_listContext differentiates from other interfaces. + IsExecute_using_argument_listContext() +} + +type Execute_using_argument_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExecute_using_argument_listContext() *Execute_using_argument_listContext { + var p = new(Execute_using_argument_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_execute_using_argument_list + return p +} + +func InitEmptyExecute_using_argument_listContext(p *Execute_using_argument_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_execute_using_argument_list +} + +func (*Execute_using_argument_listContext) IsExecute_using_argument_listContext() {} + +func NewExecute_using_argument_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Execute_using_argument_listContext { + var p = new(Execute_using_argument_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_execute_using_argument_list + + return p +} + +func (s *Execute_using_argument_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Execute_using_argument_listContext) AllExecute_using_argument() []IExecute_using_argumentContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExecute_using_argumentContext); ok { + len++ + } + } + + tst := make([]IExecute_using_argumentContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExecute_using_argumentContext); ok { + tst[i] = t.(IExecute_using_argumentContext) + i++ + } + } + + return tst +} + +func (s *Execute_using_argument_listContext) Execute_using_argument(i int) IExecute_using_argumentContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_using_argumentContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExecute_using_argumentContext) +} + +func (s *Execute_using_argument_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Execute_using_argument_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Execute_using_argument_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Execute_using_argument_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Execute_using_argument_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterExecute_using_argument_list(s) + } +} + +func (s *Execute_using_argument_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitExecute_using_argument_list(s) + } +} + +func (s *Execute_using_argument_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitExecute_using_argument_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Execute_using_argument_list() (localctx IExecute_using_argument_listContext) { + localctx = NewExecute_using_argument_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 164, GoogleSQLParserRULE_execute_using_argument_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1982) + p.Execute_using_argument() + } + p.SetState(1987) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(1983) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1984) + p.Execute_using_argument() + } + + p.SetState(1989) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExecute_using_argumentContext is an interface to support dynamic dispatch. +type IExecute_using_argumentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + AS_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsExecute_using_argumentContext differentiates from other interfaces. + IsExecute_using_argumentContext() +} + +type Execute_using_argumentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExecute_using_argumentContext() *Execute_using_argumentContext { + var p = new(Execute_using_argumentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_execute_using_argument + return p +} + +func InitEmptyExecute_using_argumentContext(p *Execute_using_argumentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_execute_using_argument +} + +func (*Execute_using_argumentContext) IsExecute_using_argumentContext() {} + +func NewExecute_using_argumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Execute_using_argumentContext { + var p = new(Execute_using_argumentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_execute_using_argument + + return p +} + +func (s *Execute_using_argumentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Execute_using_argumentContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Execute_using_argumentContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Execute_using_argumentContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Execute_using_argumentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Execute_using_argumentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Execute_using_argumentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterExecute_using_argument(s) + } +} + +func (s *Execute_using_argumentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitExecute_using_argument(s) + } +} + +func (s *Execute_using_argumentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitExecute_using_argument(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Execute_using_argument() (localctx IExecute_using_argumentContext) { + localctx = NewExecute_using_argumentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 166, GoogleSQLParserRULE_execute_using_argument) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1990) + p.expression(0) + } + p.SetState(1993) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(1991) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1992) + p.Identifier() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDescribe_statementContext is an interface to support dynamic dispatch. +type IDescribe_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe_keyword() IDescribe_keywordContext + Describe_info() IDescribe_infoContext + + // IsDescribe_statementContext differentiates from other interfaces. + IsDescribe_statementContext() +} + +type Describe_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_statementContext() *Describe_statementContext { + var p = new(Describe_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_describe_statement + return p +} + +func InitEmptyDescribe_statementContext(p *Describe_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_describe_statement +} + +func (*Describe_statementContext) IsDescribe_statementContext() {} + +func NewDescribe_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_statementContext { + var p = new(Describe_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_describe_statement + + return p +} + +func (s *Describe_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_statementContext) Describe_keyword() IDescribe_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_keywordContext) +} + +func (s *Describe_statementContext) Describe_info() IDescribe_infoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_infoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_infoContext) +} + +func (s *Describe_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterDescribe_statement(s) + } +} + +func (s *Describe_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitDescribe_statement(s) + } +} + +func (s *Describe_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitDescribe_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Describe_statement() (localctx IDescribe_statementContext) { + localctx = NewDescribe_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 168, GoogleSQLParserRULE_describe_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1995) + p.Describe_keyword() + } + { + p.SetState(1996) + p.Describe_info() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDescribe_infoContext is an interface to support dynamic dispatch. +type IDescribe_infoContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Maybe_slashed_or_dashed_path_expression() IMaybe_slashed_or_dashed_path_expressionContext + Identifier() IIdentifierContext + Opt_from_path_expression() IOpt_from_path_expressionContext + + // IsDescribe_infoContext differentiates from other interfaces. + IsDescribe_infoContext() +} + +type Describe_infoContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_infoContext() *Describe_infoContext { + var p = new(Describe_infoContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_describe_info + return p +} + +func InitEmptyDescribe_infoContext(p *Describe_infoContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_describe_info +} + +func (*Describe_infoContext) IsDescribe_infoContext() {} + +func NewDescribe_infoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_infoContext { + var p = new(Describe_infoContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_describe_info + + return p +} + +func (s *Describe_infoContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_infoContext) Maybe_slashed_or_dashed_path_expression() IMaybe_slashed_or_dashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_slashed_or_dashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_slashed_or_dashed_path_expressionContext) +} + +func (s *Describe_infoContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Describe_infoContext) Opt_from_path_expression() IOpt_from_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_from_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_from_path_expressionContext) +} + +func (s *Describe_infoContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_infoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_infoContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterDescribe_info(s) + } +} + +func (s *Describe_infoContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitDescribe_info(s) + } +} + +func (s *Describe_infoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitDescribe_info(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Describe_info() (localctx IDescribe_infoContext) { + localctx = NewDescribe_infoContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 170, GoogleSQLParserRULE_describe_info) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(1999) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 115, p.GetParserRuleContext()) == 1 { + { + p.SetState(1998) + p.Identifier() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2001) + p.Maybe_slashed_or_dashed_path_expression() + } + p.SetState(2003) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserFROM_SYMBOL { + { + p.SetState(2002) + p.Opt_from_path_expression() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_from_path_expressionContext is an interface to support dynamic dispatch. +type IOpt_from_path_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM_SYMBOL() antlr.TerminalNode + Maybe_slashed_or_dashed_path_expression() IMaybe_slashed_or_dashed_path_expressionContext + + // IsOpt_from_path_expressionContext differentiates from other interfaces. + IsOpt_from_path_expressionContext() +} + +type Opt_from_path_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_from_path_expressionContext() *Opt_from_path_expressionContext { + var p = new(Opt_from_path_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_from_path_expression + return p +} + +func InitEmptyOpt_from_path_expressionContext(p *Opt_from_path_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_from_path_expression +} + +func (*Opt_from_path_expressionContext) IsOpt_from_path_expressionContext() {} + +func NewOpt_from_path_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_from_path_expressionContext { + var p = new(Opt_from_path_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_from_path_expression + + return p +} + +func (s *Opt_from_path_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_from_path_expressionContext) FROM_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFROM_SYMBOL, 0) +} + +func (s *Opt_from_path_expressionContext) Maybe_slashed_or_dashed_path_expression() IMaybe_slashed_or_dashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_slashed_or_dashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_slashed_or_dashed_path_expressionContext) +} + +func (s *Opt_from_path_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_from_path_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_from_path_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_from_path_expression(s) + } +} + +func (s *Opt_from_path_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_from_path_expression(s) + } +} + +func (s *Opt_from_path_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_from_path_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_from_path_expression() (localctx IOpt_from_path_expressionContext) { + localctx = NewOpt_from_path_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 172, GoogleSQLParserRULE_opt_from_path_expression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2005) + p.Match(GoogleSQLParserFROM_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2006) + p.Maybe_slashed_or_dashed_path_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDescribe_keywordContext is an interface to support dynamic dispatch. +type IDescribe_keywordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DESCRIBE_SYMBOL() antlr.TerminalNode + DESC_SYMBOL() antlr.TerminalNode + + // IsDescribe_keywordContext differentiates from other interfaces. + IsDescribe_keywordContext() +} + +type Describe_keywordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_keywordContext() *Describe_keywordContext { + var p = new(Describe_keywordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_describe_keyword + return p +} + +func InitEmptyDescribe_keywordContext(p *Describe_keywordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_describe_keyword +} + +func (*Describe_keywordContext) IsDescribe_keywordContext() {} + +func NewDescribe_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_keywordContext { + var p = new(Describe_keywordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_describe_keyword + + return p +} + +func (s *Describe_keywordContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_keywordContext) DESCRIBE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDESCRIBE_SYMBOL, 0) +} + +func (s *Describe_keywordContext) DESC_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDESC_SYMBOL, 0) +} + +func (s *Describe_keywordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_keywordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterDescribe_keyword(s) + } +} + +func (s *Describe_keywordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitDescribe_keyword(s) + } +} + +func (s *Describe_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitDescribe_keyword(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Describe_keyword() (localctx IDescribe_keywordContext) { + localctx = NewDescribe_keywordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 174, GoogleSQLParserRULE_describe_keyword) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2008) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserDESC_SYMBOL || _la == GoogleSQLParserDESCRIBE_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDefine_table_statementContext is an interface to support dynamic dispatch. +type IDefine_table_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFINE_SYMBOL() antlr.TerminalNode + TABLE_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + Options_list() IOptions_listContext + + // IsDefine_table_statementContext differentiates from other interfaces. + IsDefine_table_statementContext() +} + +type Define_table_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefine_table_statementContext() *Define_table_statementContext { + var p = new(Define_table_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_define_table_statement + return p +} + +func InitEmptyDefine_table_statementContext(p *Define_table_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_define_table_statement +} + +func (*Define_table_statementContext) IsDefine_table_statementContext() {} + +func NewDefine_table_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Define_table_statementContext { + var p = new(Define_table_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_define_table_statement + + return p +} + +func (s *Define_table_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Define_table_statementContext) DEFINE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDEFINE_SYMBOL, 0) +} + +func (s *Define_table_statementContext) TABLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTABLE_SYMBOL, 0) +} + +func (s *Define_table_statementContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Define_table_statementContext) Options_list() IOptions_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptions_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptions_listContext) +} + +func (s *Define_table_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Define_table_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Define_table_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterDefine_table_statement(s) + } +} + +func (s *Define_table_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitDefine_table_statement(s) + } +} + +func (s *Define_table_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitDefine_table_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Define_table_statement() (localctx IDefine_table_statementContext) { + localctx = NewDefine_table_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 176, GoogleSQLParserRULE_define_table_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2010) + p.Match(GoogleSQLParserDEFINE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2011) + p.Match(GoogleSQLParserTABLE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2012) + p.Path_expression() + } + p.SetState(2014) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL { + { + p.SetState(2013) + p.Options_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_entity_statementContext is an interface to support dynamic dispatch. +type ICreate_entity_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE_SYMBOL() antlr.TerminalNode + Generic_entity_type() IGeneric_entity_typeContext + Path_expression() IPath_expressionContext + Opt_or_replace() IOpt_or_replaceContext + Opt_if_not_exists() IOpt_if_not_existsContext + Opt_options_list() IOpt_options_listContext + Opt_generic_entity_body() IOpt_generic_entity_bodyContext + + // IsCreate_entity_statementContext differentiates from other interfaces. + IsCreate_entity_statementContext() +} + +type Create_entity_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_entity_statementContext() *Create_entity_statementContext { + var p = new(Create_entity_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_entity_statement + return p +} + +func InitEmptyCreate_entity_statementContext(p *Create_entity_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_entity_statement +} + +func (*Create_entity_statementContext) IsCreate_entity_statementContext() {} + +func NewCreate_entity_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_entity_statementContext { + var p = new(Create_entity_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_create_entity_statement + + return p +} + +func (s *Create_entity_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_entity_statementContext) CREATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCREATE_SYMBOL, 0) +} + +func (s *Create_entity_statementContext) Generic_entity_type() IGeneric_entity_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneric_entity_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneric_entity_typeContext) +} + +func (s *Create_entity_statementContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Create_entity_statementContext) Opt_or_replace() IOpt_or_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_replaceContext) +} + +func (s *Create_entity_statementContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *Create_entity_statementContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Create_entity_statementContext) Opt_generic_entity_body() IOpt_generic_entity_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_generic_entity_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_generic_entity_bodyContext) +} + +func (s *Create_entity_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_entity_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_entity_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCreate_entity_statement(s) + } +} + +func (s *Create_entity_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCreate_entity_statement(s) + } +} + +func (s *Create_entity_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCreate_entity_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Create_entity_statement() (localctx ICreate_entity_statementContext) { + localctx = NewCreate_entity_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 178, GoogleSQLParserRULE_create_entity_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2016) + p.Match(GoogleSQLParserCREATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2018) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOR_SYMBOL { + { + p.SetState(2017) + p.Opt_or_replace() + } + + } + { + p.SetState(2020) + p.Generic_entity_type() + } + p.SetState(2022) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(2021) + p.Opt_if_not_exists() + } + + } + { + p.SetState(2024) + p.Path_expression() + } + p.SetState(2026) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(2025) + p.Opt_options_list() + } + + } + p.SetState(2029) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(2028) + p.Opt_generic_entity_body() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_generic_entity_bodyContext is an interface to support dynamic dispatch. +type IOpt_generic_entity_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AS_SYMBOL() antlr.TerminalNode + Generic_entity_body() IGeneric_entity_bodyContext + + // IsOpt_generic_entity_bodyContext differentiates from other interfaces. + IsOpt_generic_entity_bodyContext() +} + +type Opt_generic_entity_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_generic_entity_bodyContext() *Opt_generic_entity_bodyContext { + var p = new(Opt_generic_entity_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_generic_entity_body + return p +} + +func InitEmptyOpt_generic_entity_bodyContext(p *Opt_generic_entity_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_generic_entity_body +} + +func (*Opt_generic_entity_bodyContext) IsOpt_generic_entity_bodyContext() {} + +func NewOpt_generic_entity_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_generic_entity_bodyContext { + var p = new(Opt_generic_entity_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_generic_entity_body + + return p +} + +func (s *Opt_generic_entity_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_generic_entity_bodyContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Opt_generic_entity_bodyContext) Generic_entity_body() IGeneric_entity_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneric_entity_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneric_entity_bodyContext) +} + +func (s *Opt_generic_entity_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_generic_entity_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_generic_entity_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_generic_entity_body(s) + } +} + +func (s *Opt_generic_entity_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_generic_entity_body(s) + } +} + +func (s *Opt_generic_entity_bodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_generic_entity_body(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_generic_entity_body() (localctx IOpt_generic_entity_bodyContext) { + localctx = NewOpt_generic_entity_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 180, GoogleSQLParserRULE_opt_generic_entity_body) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2031) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2032) + p.Generic_entity_body() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_view_statementContext is an interface to support dynamic dispatch. +type ICreate_view_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE_SYMBOL() antlr.TerminalNode + VIEW_SYMBOL() antlr.TerminalNode + Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext + As_query() IAs_queryContext + Opt_or_replace() IOpt_or_replaceContext + Opt_create_scope() IOpt_create_scopeContext + RECURSIVE_SYMBOL() antlr.TerminalNode + Opt_if_not_exists() IOpt_if_not_existsContext + Column_with_options_list() IColumn_with_options_listContext + Opt_sql_security_clause() IOpt_sql_security_clauseContext + Opt_options_list() IOpt_options_listContext + MATERIALIZED_SYMBOL() antlr.TerminalNode + AS_SYMBOL() antlr.TerminalNode + Query_or_replica_source() IQuery_or_replica_sourceContext + Partition_by_clause_prefix_no_hint() IPartition_by_clause_prefix_no_hintContext + Cluster_by_clause_prefix_no_hint() ICluster_by_clause_prefix_no_hintContext + APPROX_SYMBOL() antlr.TerminalNode + + // IsCreate_view_statementContext differentiates from other interfaces. + IsCreate_view_statementContext() +} + +type Create_view_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_view_statementContext() *Create_view_statementContext { + var p = new(Create_view_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_view_statement + return p +} + +func InitEmptyCreate_view_statementContext(p *Create_view_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_view_statement +} + +func (*Create_view_statementContext) IsCreate_view_statementContext() {} + +func NewCreate_view_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_view_statementContext { + var p = new(Create_view_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_create_view_statement + + return p +} + +func (s *Create_view_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_view_statementContext) CREATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCREATE_SYMBOL, 0) +} + +func (s *Create_view_statementContext) VIEW_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserVIEW_SYMBOL, 0) +} + +func (s *Create_view_statementContext) Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_dashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_dashed_path_expressionContext) +} + +func (s *Create_view_statementContext) As_query() IAs_queryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_queryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_queryContext) +} + +func (s *Create_view_statementContext) Opt_or_replace() IOpt_or_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_replaceContext) +} + +func (s *Create_view_statementContext) Opt_create_scope() IOpt_create_scopeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_create_scopeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_create_scopeContext) +} + +func (s *Create_view_statementContext) RECURSIVE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRECURSIVE_SYMBOL, 0) +} + +func (s *Create_view_statementContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *Create_view_statementContext) Column_with_options_list() IColumn_with_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_with_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_with_options_listContext) +} + +func (s *Create_view_statementContext) Opt_sql_security_clause() IOpt_sql_security_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_sql_security_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_sql_security_clauseContext) +} + +func (s *Create_view_statementContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Create_view_statementContext) MATERIALIZED_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMATERIALIZED_SYMBOL, 0) +} + +func (s *Create_view_statementContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Create_view_statementContext) Query_or_replica_source() IQuery_or_replica_sourceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_or_replica_sourceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_or_replica_sourceContext) +} + +func (s *Create_view_statementContext) Partition_by_clause_prefix_no_hint() IPartition_by_clause_prefix_no_hintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_by_clause_prefix_no_hintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_by_clause_prefix_no_hintContext) +} + +func (s *Create_view_statementContext) Cluster_by_clause_prefix_no_hint() ICluster_by_clause_prefix_no_hintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_by_clause_prefix_no_hintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_by_clause_prefix_no_hintContext) +} + +func (s *Create_view_statementContext) APPROX_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAPPROX_SYMBOL, 0) +} + +func (s *Create_view_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_view_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_view_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCreate_view_statement(s) + } +} + +func (s *Create_view_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCreate_view_statement(s) + } +} + +func (s *Create_view_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCreate_view_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Create_view_statement() (localctx ICreate_view_statementContext) { + localctx = NewCreate_view_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 182, GoogleSQLParserRULE_create_view_statement) + var _la int + + p.SetState(2115) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 143, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2034) + p.Match(GoogleSQLParserCREATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2036) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOR_SYMBOL { + { + p.SetState(2035) + p.Opt_or_replace() + } + + } + p.SetState(2039) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-226)) & ^0x3f) == 0 && ((int64(1)<<(_la-226))&105553116266529) != 0 { + { + p.SetState(2038) + p.Opt_create_scope() + } + + } + p.SetState(2042) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserRECURSIVE_SYMBOL { + { + p.SetState(2041) + p.Match(GoogleSQLParserRECURSIVE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2044) + p.Match(GoogleSQLParserVIEW_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2046) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(2045) + p.Opt_if_not_exists() + } + + } + { + p.SetState(2048) + p.Maybe_dashed_path_expression() + } + p.SetState(2050) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL { + { + p.SetState(2049) + p.Column_with_options_list() + } + + } + p.SetState(2053) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserSQL_SYMBOL { + { + p.SetState(2052) + p.Opt_sql_security_clause() + } + + } + p.SetState(2056) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(2055) + p.Opt_options_list() + } + + } + { + p.SetState(2058) + p.As_query() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2060) + p.Match(GoogleSQLParserCREATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2062) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOR_SYMBOL { + { + p.SetState(2061) + p.Opt_or_replace() + } + + } + { + p.SetState(2064) + p.Match(GoogleSQLParserMATERIALIZED_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2066) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserRECURSIVE_SYMBOL { + { + p.SetState(2065) + p.Match(GoogleSQLParserRECURSIVE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2068) + p.Match(GoogleSQLParserVIEW_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2070) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(2069) + p.Opt_if_not_exists() + } + + } + { + p.SetState(2072) + p.Maybe_dashed_path_expression() + } + p.SetState(2074) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL { + { + p.SetState(2073) + p.Column_with_options_list() + } + + } + p.SetState(2077) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserSQL_SYMBOL { + { + p.SetState(2076) + p.Opt_sql_security_clause() + } + + } + p.SetState(2080) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserPARTITION_SYMBOL { + { + p.SetState(2079) + p.Partition_by_clause_prefix_no_hint() + } + + } + p.SetState(2083) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCLUSTER_SYMBOL { + { + p.SetState(2082) + p.Cluster_by_clause_prefix_no_hint() + } + + } + p.SetState(2086) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(2085) + p.Opt_options_list() + } + + } + { + p.SetState(2088) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2089) + p.Query_or_replica_source() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2091) + p.Match(GoogleSQLParserCREATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2093) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOR_SYMBOL { + { + p.SetState(2092) + p.Opt_or_replace() + } + + } + { + p.SetState(2095) + p.Match(GoogleSQLParserAPPROX_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2097) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserRECURSIVE_SYMBOL { + { + p.SetState(2096) + p.Match(GoogleSQLParserRECURSIVE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2099) + p.Match(GoogleSQLParserVIEW_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2101) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(2100) + p.Opt_if_not_exists() + } + + } + { + p.SetState(2103) + p.Maybe_dashed_path_expression() + } + p.SetState(2105) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL { + { + p.SetState(2104) + p.Column_with_options_list() + } + + } + p.SetState(2108) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserSQL_SYMBOL { + { + p.SetState(2107) + p.Opt_sql_security_clause() + } + + } + p.SetState(2111) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(2110) + p.Opt_options_list() + } + + } + { + p.SetState(2113) + p.As_query() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuery_or_replica_sourceContext is an interface to support dynamic dispatch. +type IQuery_or_replica_sourceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Query() IQueryContext + REPLICA_SYMBOL() antlr.TerminalNode + OF_SYMBOL() antlr.TerminalNode + Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext + + // IsQuery_or_replica_sourceContext differentiates from other interfaces. + IsQuery_or_replica_sourceContext() +} + +type Query_or_replica_sourceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuery_or_replica_sourceContext() *Query_or_replica_sourceContext { + var p = new(Query_or_replica_sourceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_query_or_replica_source + return p +} + +func InitEmptyQuery_or_replica_sourceContext(p *Query_or_replica_sourceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_query_or_replica_source +} + +func (*Query_or_replica_sourceContext) IsQuery_or_replica_sourceContext() {} + +func NewQuery_or_replica_sourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_or_replica_sourceContext { + var p = new(Query_or_replica_sourceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_query_or_replica_source + + return p +} + +func (s *Query_or_replica_sourceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Query_or_replica_sourceContext) Query() IQueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryContext) +} + +func (s *Query_or_replica_sourceContext) REPLICA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREPLICA_SYMBOL, 0) +} + +func (s *Query_or_replica_sourceContext) OF_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOF_SYMBOL, 0) +} + +func (s *Query_or_replica_sourceContext) Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_dashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_dashed_path_expressionContext) +} + +func (s *Query_or_replica_sourceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Query_or_replica_sourceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Query_or_replica_sourceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterQuery_or_replica_source(s) + } +} + +func (s *Query_or_replica_sourceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitQuery_or_replica_source(s) + } +} + +func (s *Query_or_replica_sourceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitQuery_or_replica_source(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Query_or_replica_source() (localctx IQuery_or_replica_sourceContext) { + localctx = NewQuery_or_replica_sourceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 184, GoogleSQLParserRULE_query_or_replica_source) + p.SetState(2121) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserLR_BRACKET_SYMBOL, GoogleSQLParserFROM_SYMBOL, GoogleSQLParserSELECT_SYMBOL, GoogleSQLParserWITH_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2117) + p.Query() + } + + case GoogleSQLParserREPLICA_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2118) + p.Match(GoogleSQLParserREPLICA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2119) + p.Match(GoogleSQLParserOF_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2120) + p.Maybe_dashed_path_expression() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_with_options_listContext is an interface to support dynamic dispatch. +type IColumn_with_options_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + AllColumn_with_options() []IColumn_with_optionsContext + Column_with_options(i int) IColumn_with_optionsContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsColumn_with_options_listContext differentiates from other interfaces. + IsColumn_with_options_listContext() +} + +type Column_with_options_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_with_options_listContext() *Column_with_options_listContext { + var p = new(Column_with_options_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_column_with_options_list + return p +} + +func InitEmptyColumn_with_options_listContext(p *Column_with_options_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_column_with_options_list +} + +func (*Column_with_options_listContext) IsColumn_with_options_listContext() {} + +func NewColumn_with_options_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_with_options_listContext { + var p = new(Column_with_options_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_column_with_options_list + + return p +} + +func (s *Column_with_options_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_with_options_listContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Column_with_options_listContext) AllColumn_with_options() []IColumn_with_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_with_optionsContext); ok { + len++ + } + } + + tst := make([]IColumn_with_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_with_optionsContext); ok { + tst[i] = t.(IColumn_with_optionsContext) + i++ + } + } + + return tst +} + +func (s *Column_with_options_listContext) Column_with_options(i int) IColumn_with_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_with_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_with_optionsContext) +} + +func (s *Column_with_options_listContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Column_with_options_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Column_with_options_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Column_with_options_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_with_options_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_with_options_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterColumn_with_options_list(s) + } +} + +func (s *Column_with_options_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitColumn_with_options_list(s) + } +} + +func (s *Column_with_options_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitColumn_with_options_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Column_with_options_list() (localctx IColumn_with_options_listContext) { + localctx = NewColumn_with_options_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 186, GoogleSQLParserRULE_column_with_options_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2123) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2124) + p.Column_with_options() + } + p.SetState(2129) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(2125) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2126) + p.Column_with_options() + } + + p.SetState(2131) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2132) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_with_optionsContext is an interface to support dynamic dispatch. +type IColumn_with_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Opt_options_list() IOpt_options_listContext + + // IsColumn_with_optionsContext differentiates from other interfaces. + IsColumn_with_optionsContext() +} + +type Column_with_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_with_optionsContext() *Column_with_optionsContext { + var p = new(Column_with_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_column_with_options + return p +} + +func InitEmptyColumn_with_optionsContext(p *Column_with_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_column_with_options +} + +func (*Column_with_optionsContext) IsColumn_with_optionsContext() {} + +func NewColumn_with_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_with_optionsContext { + var p = new(Column_with_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_column_with_options + + return p +} + +func (s *Column_with_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_with_optionsContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Column_with_optionsContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Column_with_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_with_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_with_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterColumn_with_options(s) + } +} + +func (s *Column_with_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitColumn_with_options(s) + } +} + +func (s *Column_with_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitColumn_with_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Column_with_options() (localctx IColumn_with_optionsContext) { + localctx = NewColumn_with_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 188, GoogleSQLParserRULE_column_with_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2134) + p.Identifier() + } + p.SetState(2136) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(2135) + p.Opt_options_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_table_statementContext is an interface to support dynamic dispatch. +type ICreate_table_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE_SYMBOL() antlr.TerminalNode + TABLE_SYMBOL() antlr.TerminalNode + Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext + Opt_or_replace() IOpt_or_replaceContext + Opt_create_scope() IOpt_create_scopeContext + Opt_if_not_exists() IOpt_if_not_existsContext + Table_element_list() ITable_element_listContext + Opt_spanner_table_options() IOpt_spanner_table_optionsContext + Opt_like_path_expression() IOpt_like_path_expressionContext + Opt_clone_table() IOpt_clone_tableContext + Opt_copy_table() IOpt_copy_tableContext + Opt_default_collate_clause() IOpt_default_collate_clauseContext + Partition_by_clause_prefix_no_hint() IPartition_by_clause_prefix_no_hintContext + Cluster_by_clause_prefix_no_hint() ICluster_by_clause_prefix_no_hintContext + Opt_ttl_clause() IOpt_ttl_clauseContext + With_connection_clause() IWith_connection_clauseContext + Opt_options_list() IOpt_options_listContext + As_query() IAs_queryContext + + // IsCreate_table_statementContext differentiates from other interfaces. + IsCreate_table_statementContext() +} + +type Create_table_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_table_statementContext() *Create_table_statementContext { + var p = new(Create_table_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_table_statement + return p +} + +func InitEmptyCreate_table_statementContext(p *Create_table_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_table_statement +} + +func (*Create_table_statementContext) IsCreate_table_statementContext() {} + +func NewCreate_table_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_table_statementContext { + var p = new(Create_table_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_create_table_statement + + return p +} + +func (s *Create_table_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_table_statementContext) CREATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCREATE_SYMBOL, 0) +} + +func (s *Create_table_statementContext) TABLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTABLE_SYMBOL, 0) +} + +func (s *Create_table_statementContext) Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_dashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_dashed_path_expressionContext) +} + +func (s *Create_table_statementContext) Opt_or_replace() IOpt_or_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_replaceContext) +} + +func (s *Create_table_statementContext) Opt_create_scope() IOpt_create_scopeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_create_scopeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_create_scopeContext) +} + +func (s *Create_table_statementContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *Create_table_statementContext) Table_element_list() ITable_element_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_element_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_element_listContext) +} + +func (s *Create_table_statementContext) Opt_spanner_table_options() IOpt_spanner_table_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_spanner_table_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_spanner_table_optionsContext) +} + +func (s *Create_table_statementContext) Opt_like_path_expression() IOpt_like_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_like_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_like_path_expressionContext) +} + +func (s *Create_table_statementContext) Opt_clone_table() IOpt_clone_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_clone_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_clone_tableContext) +} + +func (s *Create_table_statementContext) Opt_copy_table() IOpt_copy_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_copy_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_copy_tableContext) +} + +func (s *Create_table_statementContext) Opt_default_collate_clause() IOpt_default_collate_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_default_collate_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_default_collate_clauseContext) +} + +func (s *Create_table_statementContext) Partition_by_clause_prefix_no_hint() IPartition_by_clause_prefix_no_hintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_by_clause_prefix_no_hintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_by_clause_prefix_no_hintContext) +} + +func (s *Create_table_statementContext) Cluster_by_clause_prefix_no_hint() ICluster_by_clause_prefix_no_hintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_by_clause_prefix_no_hintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_by_clause_prefix_no_hintContext) +} + +func (s *Create_table_statementContext) Opt_ttl_clause() IOpt_ttl_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_ttl_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_ttl_clauseContext) +} + +func (s *Create_table_statementContext) With_connection_clause() IWith_connection_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_connection_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_connection_clauseContext) +} + +func (s *Create_table_statementContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Create_table_statementContext) As_query() IAs_queryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_queryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_queryContext) +} + +func (s *Create_table_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_table_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_table_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCreate_table_statement(s) + } +} + +func (s *Create_table_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCreate_table_statement(s) + } +} + +func (s *Create_table_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCreate_table_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Create_table_statement() (localctx ICreate_table_statementContext) { + localctx = NewCreate_table_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 190, GoogleSQLParserRULE_create_table_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2138) + p.Match(GoogleSQLParserCREATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2140) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOR_SYMBOL { + { + p.SetState(2139) + p.Opt_or_replace() + } + + } + p.SetState(2143) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-226)) & ^0x3f) == 0 && ((int64(1)<<(_la-226))&105553116266529) != 0 { + { + p.SetState(2142) + p.Opt_create_scope() + } + + } + { + p.SetState(2145) + p.Match(GoogleSQLParserTABLE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2147) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(2146) + p.Opt_if_not_exists() + } + + } + { + p.SetState(2149) + p.Maybe_dashed_path_expression() + } + p.SetState(2151) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL { + { + p.SetState(2150) + p.Table_element_list() + } + + } + p.SetState(2154) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserPRIMARY_SYMBOL { + { + p.SetState(2153) + p.Opt_spanner_table_options() + } + + } + p.SetState(2157) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLIKE_SYMBOL { + { + p.SetState(2156) + p.Opt_like_path_expression() + } + + } + p.SetState(2160) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCLONE_SYMBOL { + { + p.SetState(2159) + p.Opt_clone_table() + } + + } + p.SetState(2163) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCOPY_SYMBOL { + { + p.SetState(2162) + p.Opt_copy_table() + } + + } + p.SetState(2166) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserDEFAULT_SYMBOL { + { + p.SetState(2165) + p.Opt_default_collate_clause() + } + + } + p.SetState(2169) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserPARTITION_SYMBOL { + { + p.SetState(2168) + p.Partition_by_clause_prefix_no_hint() + } + + } + p.SetState(2172) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCLUSTER_SYMBOL { + { + p.SetState(2171) + p.Cluster_by_clause_prefix_no_hint() + } + + } + p.SetState(2175) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserROW_SYMBOL { + { + p.SetState(2174) + p.Opt_ttl_clause() + } + + } + p.SetState(2178) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWITH_SYMBOL { + { + p.SetState(2177) + p.With_connection_clause() + } + + } + p.SetState(2181) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(2180) + p.Opt_options_list() + } + + } + p.SetState(2184) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(2183) + p.As_query() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_ttl_clauseContext is an interface to support dynamic dispatch. +type IOpt_ttl_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROW_SYMBOL() antlr.TerminalNode + DELETION_SYMBOL() antlr.TerminalNode + POLICY_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsOpt_ttl_clauseContext differentiates from other interfaces. + IsOpt_ttl_clauseContext() +} + +type Opt_ttl_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_ttl_clauseContext() *Opt_ttl_clauseContext { + var p = new(Opt_ttl_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_ttl_clause + return p +} + +func InitEmptyOpt_ttl_clauseContext(p *Opt_ttl_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_ttl_clause +} + +func (*Opt_ttl_clauseContext) IsOpt_ttl_clauseContext() {} + +func NewOpt_ttl_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_ttl_clauseContext { + var p = new(Opt_ttl_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_ttl_clause + + return p +} + +func (s *Opt_ttl_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_ttl_clauseContext) ROW_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserROW_SYMBOL, 0) +} + +func (s *Opt_ttl_clauseContext) DELETION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDELETION_SYMBOL, 0) +} + +func (s *Opt_ttl_clauseContext) POLICY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPOLICY_SYMBOL, 0) +} + +func (s *Opt_ttl_clauseContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Opt_ttl_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Opt_ttl_clauseContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Opt_ttl_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_ttl_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_ttl_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_ttl_clause(s) + } +} + +func (s *Opt_ttl_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_ttl_clause(s) + } +} + +func (s *Opt_ttl_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_ttl_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_ttl_clause() (localctx IOpt_ttl_clauseContext) { + localctx = NewOpt_ttl_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 192, GoogleSQLParserRULE_opt_ttl_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2186) + p.Match(GoogleSQLParserROW_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2187) + p.Match(GoogleSQLParserDELETION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2188) + p.Match(GoogleSQLParserPOLICY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2189) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2190) + p.expression(0) + } + { + p.SetState(2191) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_copy_tableContext is an interface to support dynamic dispatch. +type IOpt_copy_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COPY_SYMBOL() antlr.TerminalNode + Copy_data_source() ICopy_data_sourceContext + + // IsOpt_copy_tableContext differentiates from other interfaces. + IsOpt_copy_tableContext() +} + +type Opt_copy_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_copy_tableContext() *Opt_copy_tableContext { + var p = new(Opt_copy_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_copy_table + return p +} + +func InitEmptyOpt_copy_tableContext(p *Opt_copy_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_copy_table +} + +func (*Opt_copy_tableContext) IsOpt_copy_tableContext() {} + +func NewOpt_copy_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_copy_tableContext { + var p = new(Opt_copy_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_copy_table + + return p +} + +func (s *Opt_copy_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_copy_tableContext) COPY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOPY_SYMBOL, 0) +} + +func (s *Opt_copy_tableContext) Copy_data_source() ICopy_data_sourceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_data_sourceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_data_sourceContext) +} + +func (s *Opt_copy_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_copy_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_copy_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_copy_table(s) + } +} + +func (s *Opt_copy_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_copy_table(s) + } +} + +func (s *Opt_copy_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_copy_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_copy_table() (localctx IOpt_copy_tableContext) { + localctx = NewOpt_copy_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 194, GoogleSQLParserRULE_opt_copy_table) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2193) + p.Match(GoogleSQLParserCOPY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2194) + p.Copy_data_source() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICopy_data_sourceContext is an interface to support dynamic dispatch. +type ICopy_data_sourceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext + Opt_at_system_time() IOpt_at_system_timeContext + Where_clause() IWhere_clauseContext + + // IsCopy_data_sourceContext differentiates from other interfaces. + IsCopy_data_sourceContext() +} + +type Copy_data_sourceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCopy_data_sourceContext() *Copy_data_sourceContext { + var p = new(Copy_data_sourceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_copy_data_source + return p +} + +func InitEmptyCopy_data_sourceContext(p *Copy_data_sourceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_copy_data_source +} + +func (*Copy_data_sourceContext) IsCopy_data_sourceContext() {} + +func NewCopy_data_sourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_data_sourceContext { + var p = new(Copy_data_sourceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_copy_data_source + + return p +} + +func (s *Copy_data_sourceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Copy_data_sourceContext) Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_dashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_dashed_path_expressionContext) +} + +func (s *Copy_data_sourceContext) Opt_at_system_time() IOpt_at_system_timeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_at_system_timeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_at_system_timeContext) +} + +func (s *Copy_data_sourceContext) Where_clause() IWhere_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_clauseContext) +} + +func (s *Copy_data_sourceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Copy_data_sourceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Copy_data_sourceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCopy_data_source(s) + } +} + +func (s *Copy_data_sourceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCopy_data_source(s) + } +} + +func (s *Copy_data_sourceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCopy_data_source(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Copy_data_source() (localctx ICopy_data_sourceContext) { + localctx = NewCopy_data_sourceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 196, GoogleSQLParserRULE_copy_data_source) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2196) + p.Maybe_dashed_path_expression() + } + p.SetState(2198) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserFOR_SYMBOL { + { + p.SetState(2197) + p.Opt_at_system_time() + } + + } + p.SetState(2201) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWHERE_SYMBOL { + { + p.SetState(2200) + p.Where_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_clone_tableContext is an interface to support dynamic dispatch. +type IOpt_clone_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CLONE_SYMBOL() antlr.TerminalNode + Clone_data_source() IClone_data_sourceContext + + // IsOpt_clone_tableContext differentiates from other interfaces. + IsOpt_clone_tableContext() +} + +type Opt_clone_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_clone_tableContext() *Opt_clone_tableContext { + var p = new(Opt_clone_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_clone_table + return p +} + +func InitEmptyOpt_clone_tableContext(p *Opt_clone_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_clone_table +} + +func (*Opt_clone_tableContext) IsOpt_clone_tableContext() {} + +func NewOpt_clone_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_clone_tableContext { + var p = new(Opt_clone_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_clone_table + + return p +} + +func (s *Opt_clone_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_clone_tableContext) CLONE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCLONE_SYMBOL, 0) +} + +func (s *Opt_clone_tableContext) Clone_data_source() IClone_data_sourceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClone_data_sourceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClone_data_sourceContext) +} + +func (s *Opt_clone_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_clone_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_clone_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_clone_table(s) + } +} + +func (s *Opt_clone_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_clone_table(s) + } +} + +func (s *Opt_clone_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_clone_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_clone_table() (localctx IOpt_clone_tableContext) { + localctx = NewOpt_clone_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 198, GoogleSQLParserRULE_opt_clone_table) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2203) + p.Match(GoogleSQLParserCLONE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2204) + p.Clone_data_source() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_spanner_table_optionsContext is an interface to support dynamic dispatch. +type IOpt_spanner_table_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Spanner_primary_key() ISpanner_primary_keyContext + Opt_spanner_interleave_in_parent_clause() IOpt_spanner_interleave_in_parent_clauseContext + + // IsOpt_spanner_table_optionsContext differentiates from other interfaces. + IsOpt_spanner_table_optionsContext() +} + +type Opt_spanner_table_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_spanner_table_optionsContext() *Opt_spanner_table_optionsContext { + var p = new(Opt_spanner_table_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_spanner_table_options + return p +} + +func InitEmptyOpt_spanner_table_optionsContext(p *Opt_spanner_table_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_spanner_table_options +} + +func (*Opt_spanner_table_optionsContext) IsOpt_spanner_table_optionsContext() {} + +func NewOpt_spanner_table_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_spanner_table_optionsContext { + var p = new(Opt_spanner_table_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_spanner_table_options + + return p +} + +func (s *Opt_spanner_table_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_spanner_table_optionsContext) Spanner_primary_key() ISpanner_primary_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpanner_primary_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISpanner_primary_keyContext) +} + +func (s *Opt_spanner_table_optionsContext) Opt_spanner_interleave_in_parent_clause() IOpt_spanner_interleave_in_parent_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_spanner_interleave_in_parent_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_spanner_interleave_in_parent_clauseContext) +} + +func (s *Opt_spanner_table_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_spanner_table_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_spanner_table_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_spanner_table_options(s) + } +} + +func (s *Opt_spanner_table_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_spanner_table_options(s) + } +} + +func (s *Opt_spanner_table_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_spanner_table_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_spanner_table_options() (localctx IOpt_spanner_table_optionsContext) { + localctx = NewOpt_spanner_table_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 200, GoogleSQLParserRULE_opt_spanner_table_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2206) + p.Spanner_primary_key() + } + p.SetState(2208) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(2207) + p.Opt_spanner_interleave_in_parent_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_spanner_interleave_in_parent_clauseContext is an interface to support dynamic dispatch. +type IOpt_spanner_interleave_in_parent_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMA_SYMBOL() antlr.TerminalNode + INTERLEAVE_SYMBOL() antlr.TerminalNode + IN_SYMBOL() antlr.TerminalNode + PARENT_SYMBOL() antlr.TerminalNode + Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext + Foreign_key_on_delete() IForeign_key_on_deleteContext + + // IsOpt_spanner_interleave_in_parent_clauseContext differentiates from other interfaces. + IsOpt_spanner_interleave_in_parent_clauseContext() +} + +type Opt_spanner_interleave_in_parent_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_spanner_interleave_in_parent_clauseContext() *Opt_spanner_interleave_in_parent_clauseContext { + var p = new(Opt_spanner_interleave_in_parent_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_spanner_interleave_in_parent_clause + return p +} + +func InitEmptyOpt_spanner_interleave_in_parent_clauseContext(p *Opt_spanner_interleave_in_parent_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_spanner_interleave_in_parent_clause +} + +func (*Opt_spanner_interleave_in_parent_clauseContext) IsOpt_spanner_interleave_in_parent_clauseContext() { +} + +func NewOpt_spanner_interleave_in_parent_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_spanner_interleave_in_parent_clauseContext { + var p = new(Opt_spanner_interleave_in_parent_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_spanner_interleave_in_parent_clause + + return p +} + +func (s *Opt_spanner_interleave_in_parent_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_spanner_interleave_in_parent_clauseContext) COMMA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, 0) +} + +func (s *Opt_spanner_interleave_in_parent_clauseContext) INTERLEAVE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINTERLEAVE_SYMBOL, 0) +} + +func (s *Opt_spanner_interleave_in_parent_clauseContext) IN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIN_SYMBOL, 0) +} + +func (s *Opt_spanner_interleave_in_parent_clauseContext) PARENT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPARENT_SYMBOL, 0) +} + +func (s *Opt_spanner_interleave_in_parent_clauseContext) Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_dashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_dashed_path_expressionContext) +} + +func (s *Opt_spanner_interleave_in_parent_clauseContext) Foreign_key_on_delete() IForeign_key_on_deleteContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForeign_key_on_deleteContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForeign_key_on_deleteContext) +} + +func (s *Opt_spanner_interleave_in_parent_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_spanner_interleave_in_parent_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_spanner_interleave_in_parent_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_spanner_interleave_in_parent_clause(s) + } +} + +func (s *Opt_spanner_interleave_in_parent_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_spanner_interleave_in_parent_clause(s) + } +} + +func (s *Opt_spanner_interleave_in_parent_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_spanner_interleave_in_parent_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_spanner_interleave_in_parent_clause() (localctx IOpt_spanner_interleave_in_parent_clauseContext) { + localctx = NewOpt_spanner_interleave_in_parent_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 202, GoogleSQLParserRULE_opt_spanner_interleave_in_parent_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2210) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2211) + p.Match(GoogleSQLParserINTERLEAVE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2212) + p.Match(GoogleSQLParserIN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2213) + p.Match(GoogleSQLParserPARENT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2214) + p.Maybe_dashed_path_expression() + } + { + p.SetState(2215) + p.Foreign_key_on_delete() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISpanner_primary_keyContext is an interface to support dynamic dispatch. +type ISpanner_primary_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PRIMARY_SYMBOL() antlr.TerminalNode + KEY_SYMBOL() antlr.TerminalNode + Primary_key_element_list() IPrimary_key_element_listContext + + // IsSpanner_primary_keyContext differentiates from other interfaces. + IsSpanner_primary_keyContext() +} + +type Spanner_primary_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySpanner_primary_keyContext() *Spanner_primary_keyContext { + var p = new(Spanner_primary_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_spanner_primary_key + return p +} + +func InitEmptySpanner_primary_keyContext(p *Spanner_primary_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_spanner_primary_key +} + +func (*Spanner_primary_keyContext) IsSpanner_primary_keyContext() {} + +func NewSpanner_primary_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Spanner_primary_keyContext { + var p = new(Spanner_primary_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_spanner_primary_key + + return p +} + +func (s *Spanner_primary_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Spanner_primary_keyContext) PRIMARY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPRIMARY_SYMBOL, 0) +} + +func (s *Spanner_primary_keyContext) KEY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserKEY_SYMBOL, 0) +} + +func (s *Spanner_primary_keyContext) Primary_key_element_list() IPrimary_key_element_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimary_key_element_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimary_key_element_listContext) +} + +func (s *Spanner_primary_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Spanner_primary_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Spanner_primary_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSpanner_primary_key(s) + } +} + +func (s *Spanner_primary_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSpanner_primary_key(s) + } +} + +func (s *Spanner_primary_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSpanner_primary_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Spanner_primary_key() (localctx ISpanner_primary_keyContext) { + localctx = NewSpanner_primary_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 204, GoogleSQLParserRULE_spanner_primary_key) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2217) + p.Match(GoogleSQLParserPRIMARY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2218) + p.Match(GoogleSQLParserKEY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2219) + p.Primary_key_element_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_table_function_statementContext is an interface to support dynamic dispatch. +type ICreate_table_function_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE_SYMBOL() antlr.TerminalNode + TABLE_SYMBOL() antlr.TerminalNode + FUNCTION_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + Opt_or_replace() IOpt_or_replaceContext + Opt_create_scope() IOpt_create_scopeContext + Opt_if_not_exists() IOpt_if_not_existsContext + Opt_function_parameters() IOpt_function_parametersContext + Opt_returns() IOpt_returnsContext + Opt_sql_security_clause() IOpt_sql_security_clauseContext + Unordered_language_options() IUnordered_language_optionsContext + Opt_as_query_or_string() IOpt_as_query_or_stringContext + + // IsCreate_table_function_statementContext differentiates from other interfaces. + IsCreate_table_function_statementContext() +} + +type Create_table_function_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_table_function_statementContext() *Create_table_function_statementContext { + var p = new(Create_table_function_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_table_function_statement + return p +} + +func InitEmptyCreate_table_function_statementContext(p *Create_table_function_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_table_function_statement +} + +func (*Create_table_function_statementContext) IsCreate_table_function_statementContext() {} + +func NewCreate_table_function_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_table_function_statementContext { + var p = new(Create_table_function_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_create_table_function_statement + + return p +} + +func (s *Create_table_function_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_table_function_statementContext) CREATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCREATE_SYMBOL, 0) +} + +func (s *Create_table_function_statementContext) TABLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTABLE_SYMBOL, 0) +} + +func (s *Create_table_function_statementContext) FUNCTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFUNCTION_SYMBOL, 0) +} + +func (s *Create_table_function_statementContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Create_table_function_statementContext) Opt_or_replace() IOpt_or_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_replaceContext) +} + +func (s *Create_table_function_statementContext) Opt_create_scope() IOpt_create_scopeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_create_scopeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_create_scopeContext) +} + +func (s *Create_table_function_statementContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *Create_table_function_statementContext) Opt_function_parameters() IOpt_function_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_function_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_function_parametersContext) +} + +func (s *Create_table_function_statementContext) Opt_returns() IOpt_returnsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_returnsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_returnsContext) +} + +func (s *Create_table_function_statementContext) Opt_sql_security_clause() IOpt_sql_security_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_sql_security_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_sql_security_clauseContext) +} + +func (s *Create_table_function_statementContext) Unordered_language_options() IUnordered_language_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnordered_language_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnordered_language_optionsContext) +} + +func (s *Create_table_function_statementContext) Opt_as_query_or_string() IOpt_as_query_or_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_as_query_or_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_as_query_or_stringContext) +} + +func (s *Create_table_function_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_table_function_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_table_function_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCreate_table_function_statement(s) + } +} + +func (s *Create_table_function_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCreate_table_function_statement(s) + } +} + +func (s *Create_table_function_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCreate_table_function_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Create_table_function_statement() (localctx ICreate_table_function_statementContext) { + localctx = NewCreate_table_function_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 206, GoogleSQLParserRULE_create_table_function_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2221) + p.Match(GoogleSQLParserCREATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2223) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOR_SYMBOL { + { + p.SetState(2222) + p.Opt_or_replace() + } + + } + p.SetState(2226) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-226)) & ^0x3f) == 0 && ((int64(1)<<(_la-226))&105553116266529) != 0 { + { + p.SetState(2225) + p.Opt_create_scope() + } + + } + { + p.SetState(2228) + p.Match(GoogleSQLParserTABLE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2229) + p.Match(GoogleSQLParserFUNCTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2231) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(2230) + p.Opt_if_not_exists() + } + + } + { + p.SetState(2233) + p.Path_expression() + } + p.SetState(2235) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL { + { + p.SetState(2234) + p.Opt_function_parameters() + } + + } + p.SetState(2238) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserRETURNS_SYMBOL { + { + p.SetState(2237) + p.Opt_returns() + } + + } + p.SetState(2241) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserSQL_SYMBOL { + { + p.SetState(2240) + p.Opt_sql_security_clause() + } + + } + p.SetState(2244) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL || _la == GoogleSQLParserLANGUAGE_SYMBOL { + { + p.SetState(2243) + p.Unordered_language_options() + } + + } + p.SetState(2247) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(2246) + p.Opt_as_query_or_string() + } + + } + + if localctx.Opt_function_parameters() == nil { + p.NotifyErrorListeners("Syntax error: Expected (", nil, nil) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_as_query_or_stringContext is an interface to support dynamic dispatch. +type IOpt_as_query_or_stringContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + As_query() IAs_queryContext + AS_SYMBOL() antlr.TerminalNode + String_literal() IString_literalContext + + // IsOpt_as_query_or_stringContext differentiates from other interfaces. + IsOpt_as_query_or_stringContext() +} + +type Opt_as_query_or_stringContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_as_query_or_stringContext() *Opt_as_query_or_stringContext { + var p = new(Opt_as_query_or_stringContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_as_query_or_string + return p +} + +func InitEmptyOpt_as_query_or_stringContext(p *Opt_as_query_or_stringContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_as_query_or_string +} + +func (*Opt_as_query_or_stringContext) IsOpt_as_query_or_stringContext() {} + +func NewOpt_as_query_or_stringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_as_query_or_stringContext { + var p = new(Opt_as_query_or_stringContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_as_query_or_string + + return p +} + +func (s *Opt_as_query_or_stringContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_as_query_or_stringContext) As_query() IAs_queryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_queryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_queryContext) +} + +func (s *Opt_as_query_or_stringContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Opt_as_query_or_stringContext) String_literal() IString_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_literalContext) +} + +func (s *Opt_as_query_or_stringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_as_query_or_stringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_as_query_or_stringContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_as_query_or_string(s) + } +} + +func (s *Opt_as_query_or_stringContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_as_query_or_string(s) + } +} + +func (s *Opt_as_query_or_stringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_as_query_or_string(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_as_query_or_string() (localctx IOpt_as_query_or_stringContext) { + localctx = NewOpt_as_query_or_stringContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 208, GoogleSQLParserRULE_opt_as_query_or_string) + p.SetState(2254) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 173, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2251) + p.As_query() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2252) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2253) + p.string_literal(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnordered_language_optionsContext is an interface to support dynamic dispatch. +type IUnordered_language_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Language() ILanguageContext + Opt_options_list() IOpt_options_listContext + + // IsUnordered_language_optionsContext differentiates from other interfaces. + IsUnordered_language_optionsContext() +} + +type Unordered_language_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnordered_language_optionsContext() *Unordered_language_optionsContext { + var p = new(Unordered_language_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unordered_language_options + return p +} + +func InitEmptyUnordered_language_optionsContext(p *Unordered_language_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unordered_language_options +} + +func (*Unordered_language_optionsContext) IsUnordered_language_optionsContext() {} + +func NewUnordered_language_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unordered_language_optionsContext { + var p = new(Unordered_language_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_unordered_language_options + + return p +} + +func (s *Unordered_language_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unordered_language_optionsContext) Language() ILanguageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILanguageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILanguageContext) +} + +func (s *Unordered_language_optionsContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Unordered_language_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unordered_language_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unordered_language_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterUnordered_language_options(s) + } +} + +func (s *Unordered_language_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitUnordered_language_options(s) + } +} + +func (s *Unordered_language_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitUnordered_language_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Unordered_language_options() (localctx IUnordered_language_optionsContext) { + localctx = NewUnordered_language_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 210, GoogleSQLParserRULE_unordered_language_options) + var _la int + + p.SetState(2264) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserLANGUAGE_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2256) + p.Language() + } + p.SetState(2258) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(2257) + p.Opt_options_list() + } + + } + + case GoogleSQLParserOPTIONS_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2260) + p.Opt_options_list() + } + p.SetState(2262) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLANGUAGE_SYMBOL { + { + p.SetState(2261) + p.Language() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_function_parametersContext is an interface to support dynamic dispatch. +type IOpt_function_parametersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + RR_BRACKET_SYMBOL() antlr.TerminalNode + AllFunction_parameter() []IFunction_parameterContext + Function_parameter(i int) IFunction_parameterContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsOpt_function_parametersContext differentiates from other interfaces. + IsOpt_function_parametersContext() +} + +type Opt_function_parametersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_function_parametersContext() *Opt_function_parametersContext { + var p = new(Opt_function_parametersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_function_parameters + return p +} + +func InitEmptyOpt_function_parametersContext(p *Opt_function_parametersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_function_parameters +} + +func (*Opt_function_parametersContext) IsOpt_function_parametersContext() {} + +func NewOpt_function_parametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_function_parametersContext { + var p = new(Opt_function_parametersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_function_parameters + + return p +} + +func (s *Opt_function_parametersContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_function_parametersContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Opt_function_parametersContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Opt_function_parametersContext) AllFunction_parameter() []IFunction_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunction_parameterContext); ok { + len++ + } + } + + tst := make([]IFunction_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunction_parameterContext); ok { + tst[i] = t.(IFunction_parameterContext) + i++ + } + } + + return tst +} + +func (s *Opt_function_parametersContext) Function_parameter(i int) IFunction_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunction_parameterContext) +} + +func (s *Opt_function_parametersContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Opt_function_parametersContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Opt_function_parametersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_function_parametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_function_parametersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_function_parameters(s) + } +} + +func (s *Opt_function_parametersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_function_parameters(s) + } +} + +func (s *Opt_function_parametersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_function_parameters(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_function_parameters() (localctx IOpt_function_parametersContext) { + localctx = NewOpt_function_parametersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 212, GoogleSQLParserRULE_opt_function_parameters) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2266) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2275) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-56)) & ^0x3f) == 0 && ((int64(1)<<(_la-56))&-254304519003570175) != 0) || ((int64((_la-120)) & ^0x3f) == 0 && ((int64(1)<<(_la-120))&-1) != 0) || ((int64((_la-184)) & ^0x3f) == 0 && ((int64(1)<<(_la-184))&-1) != 0) || ((int64((_la-248)) & ^0x3f) == 0 && ((int64(1)<<(_la-248))&140737488354815) != 0) || ((int64((_la-333)) & ^0x3f) == 0 && ((int64(1)<<(_la-333))&4286574721) != 0) { + { + p.SetState(2267) + p.Function_parameter() + } + p.SetState(2272) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(2268) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2269) + p.Function_parameter() + } + + p.SetState(2274) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(2277) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_snapshot_statementContext is an interface to support dynamic dispatch. +type ICreate_snapshot_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE_SYMBOL() antlr.TerminalNode + SNAPSHOT_SYMBOL() antlr.TerminalNode + Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext + CLONE_SYMBOL() antlr.TerminalNode + Clone_data_source() IClone_data_sourceContext + TABLE_SYMBOL() antlr.TerminalNode + Schema_object_kind() ISchema_object_kindContext + Opt_or_replace() IOpt_or_replaceContext + Opt_if_not_exists() IOpt_if_not_existsContext + Opt_options_list() IOpt_options_listContext + + // IsCreate_snapshot_statementContext differentiates from other interfaces. + IsCreate_snapshot_statementContext() +} + +type Create_snapshot_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_snapshot_statementContext() *Create_snapshot_statementContext { + var p = new(Create_snapshot_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_snapshot_statement + return p +} + +func InitEmptyCreate_snapshot_statementContext(p *Create_snapshot_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_snapshot_statement +} + +func (*Create_snapshot_statementContext) IsCreate_snapshot_statementContext() {} + +func NewCreate_snapshot_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_snapshot_statementContext { + var p = new(Create_snapshot_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_create_snapshot_statement + + return p +} + +func (s *Create_snapshot_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_snapshot_statementContext) CREATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCREATE_SYMBOL, 0) +} + +func (s *Create_snapshot_statementContext) SNAPSHOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSNAPSHOT_SYMBOL, 0) +} + +func (s *Create_snapshot_statementContext) Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_dashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_dashed_path_expressionContext) +} + +func (s *Create_snapshot_statementContext) CLONE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCLONE_SYMBOL, 0) +} + +func (s *Create_snapshot_statementContext) Clone_data_source() IClone_data_sourceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClone_data_sourceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClone_data_sourceContext) +} + +func (s *Create_snapshot_statementContext) TABLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTABLE_SYMBOL, 0) +} + +func (s *Create_snapshot_statementContext) Schema_object_kind() ISchema_object_kindContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_object_kindContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_object_kindContext) +} + +func (s *Create_snapshot_statementContext) Opt_or_replace() IOpt_or_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_replaceContext) +} + +func (s *Create_snapshot_statementContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *Create_snapshot_statementContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Create_snapshot_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_snapshot_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_snapshot_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCreate_snapshot_statement(s) + } +} + +func (s *Create_snapshot_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCreate_snapshot_statement(s) + } +} + +func (s *Create_snapshot_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCreate_snapshot_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Create_snapshot_statement() (localctx ICreate_snapshot_statementContext) { + localctx = NewCreate_snapshot_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 214, GoogleSQLParserRULE_create_snapshot_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2279) + p.Match(GoogleSQLParserCREATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2281) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOR_SYMBOL { + { + p.SetState(2280) + p.Opt_or_replace() + } + + } + { + p.SetState(2283) + p.Match(GoogleSQLParserSNAPSHOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2286) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserTABLE_SYMBOL: + { + p.SetState(2284) + p.Match(GoogleSQLParserTABLE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserVIEW_SYMBOL: + { + p.SetState(2285) + p.Schema_object_kind() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(2289) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(2288) + p.Opt_if_not_exists() + } + + } + { + p.SetState(2291) + p.Maybe_dashed_path_expression() + } + { + p.SetState(2292) + p.Match(GoogleSQLParserCLONE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2293) + p.Clone_data_source() + } + p.SetState(2295) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(2294) + p.Opt_options_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_external_schema_statementContext is an interface to support dynamic dispatch. +type ICreate_external_schema_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE_SYMBOL() antlr.TerminalNode + EXTERNAL_SYMBOL() antlr.TerminalNode + SCHEMA_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + Opt_options_list() IOpt_options_listContext + Opt_or_replace() IOpt_or_replaceContext + Opt_create_scope() IOpt_create_scopeContext + Opt_if_not_exists() IOpt_if_not_existsContext + With_connection_clause() IWith_connection_clauseContext + + // IsCreate_external_schema_statementContext differentiates from other interfaces. + IsCreate_external_schema_statementContext() +} + +type Create_external_schema_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_external_schema_statementContext() *Create_external_schema_statementContext { + var p = new(Create_external_schema_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_external_schema_statement + return p +} + +func InitEmptyCreate_external_schema_statementContext(p *Create_external_schema_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_external_schema_statement +} + +func (*Create_external_schema_statementContext) IsCreate_external_schema_statementContext() {} + +func NewCreate_external_schema_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_external_schema_statementContext { + var p = new(Create_external_schema_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_create_external_schema_statement + + return p +} + +func (s *Create_external_schema_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_external_schema_statementContext) CREATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCREATE_SYMBOL, 0) +} + +func (s *Create_external_schema_statementContext) EXTERNAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXTERNAL_SYMBOL, 0) +} + +func (s *Create_external_schema_statementContext) SCHEMA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSCHEMA_SYMBOL, 0) +} + +func (s *Create_external_schema_statementContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Create_external_schema_statementContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Create_external_schema_statementContext) Opt_or_replace() IOpt_or_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_replaceContext) +} + +func (s *Create_external_schema_statementContext) Opt_create_scope() IOpt_create_scopeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_create_scopeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_create_scopeContext) +} + +func (s *Create_external_schema_statementContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *Create_external_schema_statementContext) With_connection_clause() IWith_connection_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_connection_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_connection_clauseContext) +} + +func (s *Create_external_schema_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_external_schema_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_external_schema_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCreate_external_schema_statement(s) + } +} + +func (s *Create_external_schema_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCreate_external_schema_statement(s) + } +} + +func (s *Create_external_schema_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCreate_external_schema_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Create_external_schema_statement() (localctx ICreate_external_schema_statementContext) { + localctx = NewCreate_external_schema_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 216, GoogleSQLParserRULE_create_external_schema_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2297) + p.Match(GoogleSQLParserCREATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2299) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOR_SYMBOL { + { + p.SetState(2298) + p.Opt_or_replace() + } + + } + p.SetState(2302) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-226)) & ^0x3f) == 0 && ((int64(1)<<(_la-226))&105553116266529) != 0 { + { + p.SetState(2301) + p.Opt_create_scope() + } + + } + { + p.SetState(2304) + p.Match(GoogleSQLParserEXTERNAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2305) + p.Match(GoogleSQLParserSCHEMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2307) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(2306) + p.Opt_if_not_exists() + } + + } + { + p.SetState(2309) + p.Path_expression() + } + p.SetState(2311) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWITH_SYMBOL { + { + p.SetState(2310) + p.With_connection_clause() + } + + } + { + p.SetState(2313) + p.Opt_options_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_schema_statementContext is an interface to support dynamic dispatch. +type ICreate_schema_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE_SYMBOL() antlr.TerminalNode + SCHEMA_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + Opt_or_replace() IOpt_or_replaceContext + Opt_if_not_exists() IOpt_if_not_existsContext + Opt_default_collate_clause() IOpt_default_collate_clauseContext + Opt_options_list() IOpt_options_listContext + + // IsCreate_schema_statementContext differentiates from other interfaces. + IsCreate_schema_statementContext() +} + +type Create_schema_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_schema_statementContext() *Create_schema_statementContext { + var p = new(Create_schema_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_schema_statement + return p +} + +func InitEmptyCreate_schema_statementContext(p *Create_schema_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_schema_statement +} + +func (*Create_schema_statementContext) IsCreate_schema_statementContext() {} + +func NewCreate_schema_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_schema_statementContext { + var p = new(Create_schema_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_create_schema_statement + + return p +} + +func (s *Create_schema_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_schema_statementContext) CREATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCREATE_SYMBOL, 0) +} + +func (s *Create_schema_statementContext) SCHEMA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSCHEMA_SYMBOL, 0) +} + +func (s *Create_schema_statementContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Create_schema_statementContext) Opt_or_replace() IOpt_or_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_replaceContext) +} + +func (s *Create_schema_statementContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *Create_schema_statementContext) Opt_default_collate_clause() IOpt_default_collate_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_default_collate_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_default_collate_clauseContext) +} + +func (s *Create_schema_statementContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Create_schema_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_schema_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_schema_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCreate_schema_statement(s) + } +} + +func (s *Create_schema_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCreate_schema_statement(s) + } +} + +func (s *Create_schema_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCreate_schema_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Create_schema_statement() (localctx ICreate_schema_statementContext) { + localctx = NewCreate_schema_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 218, GoogleSQLParserRULE_create_schema_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2315) + p.Match(GoogleSQLParserCREATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2317) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOR_SYMBOL { + { + p.SetState(2316) + p.Opt_or_replace() + } + + } + { + p.SetState(2319) + p.Match(GoogleSQLParserSCHEMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2321) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(2320) + p.Opt_if_not_exists() + } + + } + { + p.SetState(2323) + p.Path_expression() + } + p.SetState(2325) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserDEFAULT_SYMBOL { + { + p.SetState(2324) + p.Opt_default_collate_clause() + } + + } + p.SetState(2328) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(2327) + p.Opt_options_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_property_graph_statementContext is an interface to support dynamic dispatch. +type ICreate_property_graph_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE_SYMBOL() antlr.TerminalNode + PROPERTY_SYMBOL() antlr.TerminalNode + GRAPH_SYMBOL() antlr.TerminalNode + Opt_if_not_exists() IOpt_if_not_existsContext + Path_expression() IPath_expressionContext + NODE_SYMBOL() antlr.TerminalNode + TABLES_SYMBOL() antlr.TerminalNode + Element_table_list() IElement_table_listContext + Opt_or_replace() IOpt_or_replaceContext + Opt_options_list() IOpt_options_listContext + Opt_edge_table_clause() IOpt_edge_table_clauseContext + + // IsCreate_property_graph_statementContext differentiates from other interfaces. + IsCreate_property_graph_statementContext() +} + +type Create_property_graph_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_property_graph_statementContext() *Create_property_graph_statementContext { + var p = new(Create_property_graph_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_property_graph_statement + return p +} + +func InitEmptyCreate_property_graph_statementContext(p *Create_property_graph_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_property_graph_statement +} + +func (*Create_property_graph_statementContext) IsCreate_property_graph_statementContext() {} + +func NewCreate_property_graph_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_property_graph_statementContext { + var p = new(Create_property_graph_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_create_property_graph_statement + + return p +} + +func (s *Create_property_graph_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_property_graph_statementContext) CREATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCREATE_SYMBOL, 0) +} + +func (s *Create_property_graph_statementContext) PROPERTY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPROPERTY_SYMBOL, 0) +} + +func (s *Create_property_graph_statementContext) GRAPH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserGRAPH_SYMBOL, 0) +} + +func (s *Create_property_graph_statementContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *Create_property_graph_statementContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Create_property_graph_statementContext) NODE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNODE_SYMBOL, 0) +} + +func (s *Create_property_graph_statementContext) TABLES_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTABLES_SYMBOL, 0) +} + +func (s *Create_property_graph_statementContext) Element_table_list() IElement_table_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IElement_table_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IElement_table_listContext) +} + +func (s *Create_property_graph_statementContext) Opt_or_replace() IOpt_or_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_replaceContext) +} + +func (s *Create_property_graph_statementContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Create_property_graph_statementContext) Opt_edge_table_clause() IOpt_edge_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_edge_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_edge_table_clauseContext) +} + +func (s *Create_property_graph_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_property_graph_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_property_graph_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCreate_property_graph_statement(s) + } +} + +func (s *Create_property_graph_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCreate_property_graph_statement(s) + } +} + +func (s *Create_property_graph_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCreate_property_graph_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Create_property_graph_statement() (localctx ICreate_property_graph_statementContext) { + localctx = NewCreate_property_graph_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 220, GoogleSQLParserRULE_create_property_graph_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2330) + p.Match(GoogleSQLParserCREATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2332) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOR_SYMBOL { + { + p.SetState(2331) + p.Opt_or_replace() + } + + } + { + p.SetState(2334) + p.Match(GoogleSQLParserPROPERTY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2335) + p.Match(GoogleSQLParserGRAPH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2336) + p.Opt_if_not_exists() + } + { + p.SetState(2337) + p.Path_expression() + } + p.SetState(2339) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(2338) + p.Opt_options_list() + } + + } + { + p.SetState(2341) + p.Match(GoogleSQLParserNODE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2342) + p.Match(GoogleSQLParserTABLES_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2343) + p.Element_table_list() + } + p.SetState(2345) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserEDGE_SYMBOL { + { + p.SetState(2344) + p.Opt_edge_table_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_edge_table_clauseContext is an interface to support dynamic dispatch. +type IOpt_edge_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EDGE_SYMBOL() antlr.TerminalNode + TABLES_SYMBOL() antlr.TerminalNode + Element_table_list() IElement_table_listContext + + // IsOpt_edge_table_clauseContext differentiates from other interfaces. + IsOpt_edge_table_clauseContext() +} + +type Opt_edge_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_edge_table_clauseContext() *Opt_edge_table_clauseContext { + var p = new(Opt_edge_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_edge_table_clause + return p +} + +func InitEmptyOpt_edge_table_clauseContext(p *Opt_edge_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_edge_table_clause +} + +func (*Opt_edge_table_clauseContext) IsOpt_edge_table_clauseContext() {} + +func NewOpt_edge_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_edge_table_clauseContext { + var p = new(Opt_edge_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_edge_table_clause + + return p +} + +func (s *Opt_edge_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_edge_table_clauseContext) EDGE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEDGE_SYMBOL, 0) +} + +func (s *Opt_edge_table_clauseContext) TABLES_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTABLES_SYMBOL, 0) +} + +func (s *Opt_edge_table_clauseContext) Element_table_list() IElement_table_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IElement_table_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IElement_table_listContext) +} + +func (s *Opt_edge_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_edge_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_edge_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_edge_table_clause(s) + } +} + +func (s *Opt_edge_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_edge_table_clause(s) + } +} + +func (s *Opt_edge_table_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_edge_table_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_edge_table_clause() (localctx IOpt_edge_table_clauseContext) { + localctx = NewOpt_edge_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 222, GoogleSQLParserRULE_opt_edge_table_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2347) + p.Match(GoogleSQLParserEDGE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2348) + p.Match(GoogleSQLParserTABLES_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2349) + p.Element_table_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IElement_table_listContext is an interface to support dynamic dispatch. +type IElement_table_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + AllElement_table_definition() []IElement_table_definitionContext + Element_table_definition(i int) IElement_table_definitionContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsElement_table_listContext differentiates from other interfaces. + IsElement_table_listContext() +} + +type Element_table_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyElement_table_listContext() *Element_table_listContext { + var p = new(Element_table_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_element_table_list + return p +} + +func InitEmptyElement_table_listContext(p *Element_table_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_element_table_list +} + +func (*Element_table_listContext) IsElement_table_listContext() {} + +func NewElement_table_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Element_table_listContext { + var p = new(Element_table_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_element_table_list + + return p +} + +func (s *Element_table_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Element_table_listContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Element_table_listContext) AllElement_table_definition() []IElement_table_definitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IElement_table_definitionContext); ok { + len++ + } + } + + tst := make([]IElement_table_definitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IElement_table_definitionContext); ok { + tst[i] = t.(IElement_table_definitionContext) + i++ + } + } + + return tst +} + +func (s *Element_table_listContext) Element_table_definition(i int) IElement_table_definitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IElement_table_definitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IElement_table_definitionContext) +} + +func (s *Element_table_listContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Element_table_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Element_table_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Element_table_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Element_table_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Element_table_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterElement_table_list(s) + } +} + +func (s *Element_table_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitElement_table_list(s) + } +} + +func (s *Element_table_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitElement_table_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Element_table_list() (localctx IElement_table_listContext) { + localctx = NewElement_table_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 224, GoogleSQLParserRULE_element_table_list) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2351) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2352) + p.Element_table_definition() + } + p.SetState(2357) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 194, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2353) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2354) + p.Element_table_definition() + } + + } + p.SetState(2359) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 194, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(2361) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(2360) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2363) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IElement_table_definitionContext is an interface to support dynamic dispatch. +type IElement_table_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Path_expression() IPath_expressionContext + Opt_as_alias_with_required_as() IOpt_as_alias_with_required_asContext + Opt_key_clause() IOpt_key_clauseContext + Opt_source_node_table_clause() IOpt_source_node_table_clauseContext + Opt_dest_node_table_clause() IOpt_dest_node_table_clauseContext + Opt_label_and_properties_clause() IOpt_label_and_properties_clauseContext + + // IsElement_table_definitionContext differentiates from other interfaces. + IsElement_table_definitionContext() +} + +type Element_table_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyElement_table_definitionContext() *Element_table_definitionContext { + var p = new(Element_table_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_element_table_definition + return p +} + +func InitEmptyElement_table_definitionContext(p *Element_table_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_element_table_definition +} + +func (*Element_table_definitionContext) IsElement_table_definitionContext() {} + +func NewElement_table_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Element_table_definitionContext { + var p = new(Element_table_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_element_table_definition + + return p +} + +func (s *Element_table_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Element_table_definitionContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Element_table_definitionContext) Opt_as_alias_with_required_as() IOpt_as_alias_with_required_asContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_as_alias_with_required_asContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_as_alias_with_required_asContext) +} + +func (s *Element_table_definitionContext) Opt_key_clause() IOpt_key_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_key_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_key_clauseContext) +} + +func (s *Element_table_definitionContext) Opt_source_node_table_clause() IOpt_source_node_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_source_node_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_source_node_table_clauseContext) +} + +func (s *Element_table_definitionContext) Opt_dest_node_table_clause() IOpt_dest_node_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_dest_node_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_dest_node_table_clauseContext) +} + +func (s *Element_table_definitionContext) Opt_label_and_properties_clause() IOpt_label_and_properties_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_label_and_properties_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_label_and_properties_clauseContext) +} + +func (s *Element_table_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Element_table_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Element_table_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterElement_table_definition(s) + } +} + +func (s *Element_table_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitElement_table_definition(s) + } +} + +func (s *Element_table_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitElement_table_definition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Element_table_definition() (localctx IElement_table_definitionContext) { + localctx = NewElement_table_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 226, GoogleSQLParserRULE_element_table_definition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2365) + p.Path_expression() + } + p.SetState(2367) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(2366) + p.Opt_as_alias_with_required_as() + } + + } + p.SetState(2370) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserKEY_SYMBOL { + { + p.SetState(2369) + p.Opt_key_clause() + } + + } + p.SetState(2373) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserSOURCE_SYMBOL { + { + p.SetState(2372) + p.Opt_source_node_table_clause() + } + + } + p.SetState(2376) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserDESTINATION_SYMBOL { + { + p.SetState(2375) + p.Opt_dest_node_table_clause() + } + + } + p.SetState(2379) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-324)) & ^0x3f) == 0 && ((int64(1)<<(_la-324))&100671489) != 0 { + { + p.SetState(2378) + p.Opt_label_and_properties_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_label_and_properties_clauseContext is an interface to support dynamic dispatch. +type IOpt_label_and_properties_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Properties_clause() IProperties_clauseContext + Label_and_properties_list() ILabel_and_properties_listContext + + // IsOpt_label_and_properties_clauseContext differentiates from other interfaces. + IsOpt_label_and_properties_clauseContext() +} + +type Opt_label_and_properties_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_label_and_properties_clauseContext() *Opt_label_and_properties_clauseContext { + var p = new(Opt_label_and_properties_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_label_and_properties_clause + return p +} + +func InitEmptyOpt_label_and_properties_clauseContext(p *Opt_label_and_properties_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_label_and_properties_clause +} + +func (*Opt_label_and_properties_clauseContext) IsOpt_label_and_properties_clauseContext() {} + +func NewOpt_label_and_properties_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_label_and_properties_clauseContext { + var p = new(Opt_label_and_properties_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_label_and_properties_clause + + return p +} + +func (s *Opt_label_and_properties_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_label_and_properties_clauseContext) Properties_clause() IProperties_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProperties_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProperties_clauseContext) +} + +func (s *Opt_label_and_properties_clauseContext) Label_and_properties_list() ILabel_and_properties_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_and_properties_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_and_properties_listContext) +} + +func (s *Opt_label_and_properties_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_label_and_properties_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_label_and_properties_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_label_and_properties_clause(s) + } +} + +func (s *Opt_label_and_properties_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_label_and_properties_clause(s) + } +} + +func (s *Opt_label_and_properties_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_label_and_properties_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_label_and_properties_clause() (localctx IOpt_label_and_properties_clauseContext) { + localctx = NewOpt_label_and_properties_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 228, GoogleSQLParserRULE_opt_label_and_properties_clause) + p.SetState(2383) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserNO_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2381) + p.Properties_clause() + } + + case GoogleSQLParserDEFAULT_SYMBOL, GoogleSQLParserLABEL_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2382) + p.Label_and_properties_list() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILabel_and_properties_listContext is an interface to support dynamic dispatch. +type ILabel_and_properties_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllLabel_and_properties() []ILabel_and_propertiesContext + Label_and_properties(i int) ILabel_and_propertiesContext + + // IsLabel_and_properties_listContext differentiates from other interfaces. + IsLabel_and_properties_listContext() +} + +type Label_and_properties_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLabel_and_properties_listContext() *Label_and_properties_listContext { + var p = new(Label_and_properties_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_label_and_properties_list + return p +} + +func InitEmptyLabel_and_properties_listContext(p *Label_and_properties_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_label_and_properties_list +} + +func (*Label_and_properties_listContext) IsLabel_and_properties_listContext() {} + +func NewLabel_and_properties_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Label_and_properties_listContext { + var p = new(Label_and_properties_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_label_and_properties_list + + return p +} + +func (s *Label_and_properties_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Label_and_properties_listContext) AllLabel_and_properties() []ILabel_and_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILabel_and_propertiesContext); ok { + len++ + } + } + + tst := make([]ILabel_and_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILabel_and_propertiesContext); ok { + tst[i] = t.(ILabel_and_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Label_and_properties_listContext) Label_and_properties(i int) ILabel_and_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_and_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILabel_and_propertiesContext) +} + +func (s *Label_and_properties_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Label_and_properties_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Label_and_properties_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterLabel_and_properties_list(s) + } +} + +func (s *Label_and_properties_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitLabel_and_properties_list(s) + } +} + +func (s *Label_and_properties_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitLabel_and_properties_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Label_and_properties_list() (localctx ILabel_and_properties_listContext) { + localctx = NewLabel_and_properties_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 230, GoogleSQLParserRULE_label_and_properties_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(2386) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == GoogleSQLParserDEFAULT_SYMBOL || _la == GoogleSQLParserLABEL_SYMBOL { + { + p.SetState(2385) + p.Label_and_properties() + } + + p.SetState(2388) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILabel_and_propertiesContext is an interface to support dynamic dispatch. +type ILabel_and_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LABEL_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + DEFAULT_SYMBOL() antlr.TerminalNode + Properties_clause() IProperties_clauseContext + + // IsLabel_and_propertiesContext differentiates from other interfaces. + IsLabel_and_propertiesContext() +} + +type Label_and_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLabel_and_propertiesContext() *Label_and_propertiesContext { + var p = new(Label_and_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_label_and_properties + return p +} + +func InitEmptyLabel_and_propertiesContext(p *Label_and_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_label_and_properties +} + +func (*Label_and_propertiesContext) IsLabel_and_propertiesContext() {} + +func NewLabel_and_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Label_and_propertiesContext { + var p = new(Label_and_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_label_and_properties + + return p +} + +func (s *Label_and_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Label_and_propertiesContext) LABEL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLABEL_SYMBOL, 0) +} + +func (s *Label_and_propertiesContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Label_and_propertiesContext) DEFAULT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDEFAULT_SYMBOL, 0) +} + +func (s *Label_and_propertiesContext) Properties_clause() IProperties_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProperties_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProperties_clauseContext) +} + +func (s *Label_and_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Label_and_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Label_and_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterLabel_and_properties(s) + } +} + +func (s *Label_and_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitLabel_and_properties(s) + } +} + +func (s *Label_and_propertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitLabel_and_properties(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Label_and_properties() (localctx ILabel_and_propertiesContext) { + localctx = NewLabel_and_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 232, GoogleSQLParserRULE_label_and_properties) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(2391) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserDEFAULT_SYMBOL { + { + p.SetState(2390) + p.Match(GoogleSQLParserDEFAULT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2393) + p.Match(GoogleSQLParserLABEL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2394) + p.Identifier() + } + p.SetState(2396) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserNO_SYMBOL || _la == GoogleSQLParserPROPERTIES_SYMBOL { + { + p.SetState(2395) + p.Properties_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProperties_clauseContext is an interface to support dynamic dispatch. +type IProperties_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NO_SYMBOL() antlr.TerminalNode + PROPERTIES_SYMBOL() antlr.TerminalNode + Properties_all_columns() IProperties_all_columnsContext + Opt_except_column_list() IOpt_except_column_listContext + LR_BRACKET_SYMBOL() antlr.TerminalNode + Derived_property_list() IDerived_property_listContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsProperties_clauseContext differentiates from other interfaces. + IsProperties_clauseContext() +} + +type Properties_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProperties_clauseContext() *Properties_clauseContext { + var p = new(Properties_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_properties_clause + return p +} + +func InitEmptyProperties_clauseContext(p *Properties_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_properties_clause +} + +func (*Properties_clauseContext) IsProperties_clauseContext() {} + +func NewProperties_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Properties_clauseContext { + var p = new(Properties_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_properties_clause + + return p +} + +func (s *Properties_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Properties_clauseContext) NO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNO_SYMBOL, 0) +} + +func (s *Properties_clauseContext) PROPERTIES_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPROPERTIES_SYMBOL, 0) +} + +func (s *Properties_clauseContext) Properties_all_columns() IProperties_all_columnsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProperties_all_columnsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProperties_all_columnsContext) +} + +func (s *Properties_clauseContext) Opt_except_column_list() IOpt_except_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_except_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_except_column_listContext) +} + +func (s *Properties_clauseContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Properties_clauseContext) Derived_property_list() IDerived_property_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDerived_property_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDerived_property_listContext) +} + +func (s *Properties_clauseContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Properties_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Properties_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Properties_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterProperties_clause(s) + } +} + +func (s *Properties_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitProperties_clause(s) + } +} + +func (s *Properties_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitProperties_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Properties_clause() (localctx IProperties_clauseContext) { + localctx = NewProperties_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 234, GoogleSQLParserRULE_properties_clause) + var _la int + + p.SetState(2409) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 206, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2398) + p.Match(GoogleSQLParserNO_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2399) + p.Match(GoogleSQLParserPROPERTIES_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2400) + p.Properties_all_columns() + } + p.SetState(2402) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserEXCEPT_SYMBOL { + { + p.SetState(2401) + p.Opt_except_column_list() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2404) + p.Match(GoogleSQLParserPROPERTIES_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2405) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2406) + p.Derived_property_list() + } + { + p.SetState(2407) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDerived_property_listContext is an interface to support dynamic dispatch. +type IDerived_property_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDerived_property() []IDerived_propertyContext + Derived_property(i int) IDerived_propertyContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsDerived_property_listContext differentiates from other interfaces. + IsDerived_property_listContext() +} + +type Derived_property_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDerived_property_listContext() *Derived_property_listContext { + var p = new(Derived_property_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_derived_property_list + return p +} + +func InitEmptyDerived_property_listContext(p *Derived_property_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_derived_property_list +} + +func (*Derived_property_listContext) IsDerived_property_listContext() {} + +func NewDerived_property_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Derived_property_listContext { + var p = new(Derived_property_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_derived_property_list + + return p +} + +func (s *Derived_property_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Derived_property_listContext) AllDerived_property() []IDerived_propertyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDerived_propertyContext); ok { + len++ + } + } + + tst := make([]IDerived_propertyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDerived_propertyContext); ok { + tst[i] = t.(IDerived_propertyContext) + i++ + } + } + + return tst +} + +func (s *Derived_property_listContext) Derived_property(i int) IDerived_propertyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDerived_propertyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDerived_propertyContext) +} + +func (s *Derived_property_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Derived_property_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Derived_property_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Derived_property_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Derived_property_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterDerived_property_list(s) + } +} + +func (s *Derived_property_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitDerived_property_list(s) + } +} + +func (s *Derived_property_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitDerived_property_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Derived_property_list() (localctx IDerived_property_listContext) { + localctx = NewDerived_property_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 236, GoogleSQLParserRULE_derived_property_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2411) + p.Derived_property() + } + p.SetState(2416) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(2412) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2413) + p.Derived_property() + } + + p.SetState(2418) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDerived_propertyContext is an interface to support dynamic dispatch. +type IDerived_propertyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + Opt_as_alias_with_required_as() IOpt_as_alias_with_required_asContext + + // IsDerived_propertyContext differentiates from other interfaces. + IsDerived_propertyContext() +} + +type Derived_propertyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDerived_propertyContext() *Derived_propertyContext { + var p = new(Derived_propertyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_derived_property + return p +} + +func InitEmptyDerived_propertyContext(p *Derived_propertyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_derived_property +} + +func (*Derived_propertyContext) IsDerived_propertyContext() {} + +func NewDerived_propertyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Derived_propertyContext { + var p = new(Derived_propertyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_derived_property + + return p +} + +func (s *Derived_propertyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Derived_propertyContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Derived_propertyContext) Opt_as_alias_with_required_as() IOpt_as_alias_with_required_asContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_as_alias_with_required_asContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_as_alias_with_required_asContext) +} + +func (s *Derived_propertyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Derived_propertyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Derived_propertyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterDerived_property(s) + } +} + +func (s *Derived_propertyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitDerived_property(s) + } +} + +func (s *Derived_propertyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitDerived_property(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Derived_property() (localctx IDerived_propertyContext) { + localctx = NewDerived_propertyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 238, GoogleSQLParserRULE_derived_property) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2419) + p.expression(0) + } + p.SetState(2421) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(2420) + p.Opt_as_alias_with_required_as() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_except_column_listContext is an interface to support dynamic dispatch. +type IOpt_except_column_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXCEPT_SYMBOL() antlr.TerminalNode + Column_list() IColumn_listContext + + // IsOpt_except_column_listContext differentiates from other interfaces. + IsOpt_except_column_listContext() +} + +type Opt_except_column_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_except_column_listContext() *Opt_except_column_listContext { + var p = new(Opt_except_column_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_except_column_list + return p +} + +func InitEmptyOpt_except_column_listContext(p *Opt_except_column_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_except_column_list +} + +func (*Opt_except_column_listContext) IsOpt_except_column_listContext() {} + +func NewOpt_except_column_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_except_column_listContext { + var p = new(Opt_except_column_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_except_column_list + + return p +} + +func (s *Opt_except_column_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_except_column_listContext) EXCEPT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXCEPT_SYMBOL, 0) +} + +func (s *Opt_except_column_listContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Opt_except_column_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_except_column_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_except_column_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_except_column_list(s) + } +} + +func (s *Opt_except_column_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_except_column_list(s) + } +} + +func (s *Opt_except_column_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_except_column_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_except_column_list() (localctx IOpt_except_column_listContext) { + localctx = NewOpt_except_column_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 240, GoogleSQLParserRULE_opt_except_column_list) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2423) + p.Match(GoogleSQLParserEXCEPT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2424) + p.Column_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProperties_all_columnsContext is an interface to support dynamic dispatch. +type IProperties_all_columnsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PROPERTIES_SYMBOL() antlr.TerminalNode + ALL_SYMBOL() antlr.TerminalNode + COLUMNS_SYMBOL() antlr.TerminalNode + ARE_SYMBOL() antlr.TerminalNode + + // IsProperties_all_columnsContext differentiates from other interfaces. + IsProperties_all_columnsContext() +} + +type Properties_all_columnsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProperties_all_columnsContext() *Properties_all_columnsContext { + var p = new(Properties_all_columnsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_properties_all_columns + return p +} + +func InitEmptyProperties_all_columnsContext(p *Properties_all_columnsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_properties_all_columns +} + +func (*Properties_all_columnsContext) IsProperties_all_columnsContext() {} + +func NewProperties_all_columnsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Properties_all_columnsContext { + var p = new(Properties_all_columnsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_properties_all_columns + + return p +} + +func (s *Properties_all_columnsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Properties_all_columnsContext) PROPERTIES_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPROPERTIES_SYMBOL, 0) +} + +func (s *Properties_all_columnsContext) ALL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserALL_SYMBOL, 0) +} + +func (s *Properties_all_columnsContext) COLUMNS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOLUMNS_SYMBOL, 0) +} + +func (s *Properties_all_columnsContext) ARE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserARE_SYMBOL, 0) +} + +func (s *Properties_all_columnsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Properties_all_columnsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Properties_all_columnsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterProperties_all_columns(s) + } +} + +func (s *Properties_all_columnsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitProperties_all_columns(s) + } +} + +func (s *Properties_all_columnsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitProperties_all_columns(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Properties_all_columns() (localctx IProperties_all_columnsContext) { + localctx = NewProperties_all_columnsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 242, GoogleSQLParserRULE_properties_all_columns) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2426) + p.Match(GoogleSQLParserPROPERTIES_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2428) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserARE_SYMBOL { + { + p.SetState(2427) + p.Match(GoogleSQLParserARE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2430) + p.Match(GoogleSQLParserALL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2431) + p.Match(GoogleSQLParserCOLUMNS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_dest_node_table_clauseContext is an interface to support dynamic dispatch. +type IOpt_dest_node_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DESTINATION_SYMBOL() antlr.TerminalNode + KEY_SYMBOL() antlr.TerminalNode + AllColumn_list() []IColumn_listContext + Column_list(i int) IColumn_listContext + REFERENCES_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsOpt_dest_node_table_clauseContext differentiates from other interfaces. + IsOpt_dest_node_table_clauseContext() +} + +type Opt_dest_node_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_dest_node_table_clauseContext() *Opt_dest_node_table_clauseContext { + var p = new(Opt_dest_node_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_dest_node_table_clause + return p +} + +func InitEmptyOpt_dest_node_table_clauseContext(p *Opt_dest_node_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_dest_node_table_clause +} + +func (*Opt_dest_node_table_clauseContext) IsOpt_dest_node_table_clauseContext() {} + +func NewOpt_dest_node_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_dest_node_table_clauseContext { + var p = new(Opt_dest_node_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_dest_node_table_clause + + return p +} + +func (s *Opt_dest_node_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_dest_node_table_clauseContext) DESTINATION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDESTINATION_SYMBOL, 0) +} + +func (s *Opt_dest_node_table_clauseContext) KEY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserKEY_SYMBOL, 0) +} + +func (s *Opt_dest_node_table_clauseContext) AllColumn_list() []IColumn_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_listContext); ok { + len++ + } + } + + tst := make([]IColumn_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_listContext); ok { + tst[i] = t.(IColumn_listContext) + i++ + } + } + + return tst +} + +func (s *Opt_dest_node_table_clauseContext) Column_list(i int) IColumn_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Opt_dest_node_table_clauseContext) REFERENCES_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREFERENCES_SYMBOL, 0) +} + +func (s *Opt_dest_node_table_clauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Opt_dest_node_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_dest_node_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_dest_node_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_dest_node_table_clause(s) + } +} + +func (s *Opt_dest_node_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_dest_node_table_clause(s) + } +} + +func (s *Opt_dest_node_table_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_dest_node_table_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_dest_node_table_clause() (localctx IOpt_dest_node_table_clauseContext) { + localctx = NewOpt_dest_node_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 244, GoogleSQLParserRULE_opt_dest_node_table_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2433) + p.Match(GoogleSQLParserDESTINATION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2434) + p.Match(GoogleSQLParserKEY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2435) + p.Column_list() + } + { + p.SetState(2436) + p.Match(GoogleSQLParserREFERENCES_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2437) + p.Identifier() + } + p.SetState(2439) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL { + { + p.SetState(2438) + p.Column_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_source_node_table_clauseContext is an interface to support dynamic dispatch. +type IOpt_source_node_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SOURCE_SYMBOL() antlr.TerminalNode + KEY_SYMBOL() antlr.TerminalNode + AllColumn_list() []IColumn_listContext + Column_list(i int) IColumn_listContext + REFERENCES_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsOpt_source_node_table_clauseContext differentiates from other interfaces. + IsOpt_source_node_table_clauseContext() +} + +type Opt_source_node_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_source_node_table_clauseContext() *Opt_source_node_table_clauseContext { + var p = new(Opt_source_node_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_source_node_table_clause + return p +} + +func InitEmptyOpt_source_node_table_clauseContext(p *Opt_source_node_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_source_node_table_clause +} + +func (*Opt_source_node_table_clauseContext) IsOpt_source_node_table_clauseContext() {} + +func NewOpt_source_node_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_source_node_table_clauseContext { + var p = new(Opt_source_node_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_source_node_table_clause + + return p +} + +func (s *Opt_source_node_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_source_node_table_clauseContext) SOURCE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSOURCE_SYMBOL, 0) +} + +func (s *Opt_source_node_table_clauseContext) KEY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserKEY_SYMBOL, 0) +} + +func (s *Opt_source_node_table_clauseContext) AllColumn_list() []IColumn_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_listContext); ok { + len++ + } + } + + tst := make([]IColumn_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_listContext); ok { + tst[i] = t.(IColumn_listContext) + i++ + } + } + + return tst +} + +func (s *Opt_source_node_table_clauseContext) Column_list(i int) IColumn_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Opt_source_node_table_clauseContext) REFERENCES_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREFERENCES_SYMBOL, 0) +} + +func (s *Opt_source_node_table_clauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Opt_source_node_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_source_node_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_source_node_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_source_node_table_clause(s) + } +} + +func (s *Opt_source_node_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_source_node_table_clause(s) + } +} + +func (s *Opt_source_node_table_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_source_node_table_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_source_node_table_clause() (localctx IOpt_source_node_table_clauseContext) { + localctx = NewOpt_source_node_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 246, GoogleSQLParserRULE_opt_source_node_table_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2441) + p.Match(GoogleSQLParserSOURCE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2442) + p.Match(GoogleSQLParserKEY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2443) + p.Column_list() + } + { + p.SetState(2444) + p.Match(GoogleSQLParserREFERENCES_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2445) + p.Identifier() + } + p.SetState(2447) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL { + { + p.SetState(2446) + p.Column_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_key_clauseContext is an interface to support dynamic dispatch. +type IOpt_key_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KEY_SYMBOL() antlr.TerminalNode + Column_list() IColumn_listContext + + // IsOpt_key_clauseContext differentiates from other interfaces. + IsOpt_key_clauseContext() +} + +type Opt_key_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_key_clauseContext() *Opt_key_clauseContext { + var p = new(Opt_key_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_key_clause + return p +} + +func InitEmptyOpt_key_clauseContext(p *Opt_key_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_key_clause +} + +func (*Opt_key_clauseContext) IsOpt_key_clauseContext() {} + +func NewOpt_key_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_key_clauseContext { + var p = new(Opt_key_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_key_clause + + return p +} + +func (s *Opt_key_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_key_clauseContext) KEY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserKEY_SYMBOL, 0) +} + +func (s *Opt_key_clauseContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Opt_key_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_key_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_key_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_key_clause(s) + } +} + +func (s *Opt_key_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_key_clause(s) + } +} + +func (s *Opt_key_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_key_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_key_clause() (localctx IOpt_key_clauseContext) { + localctx = NewOpt_key_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 248, GoogleSQLParserRULE_opt_key_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2449) + p.Match(GoogleSQLParserKEY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2450) + p.Column_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_model_statementContext is an interface to support dynamic dispatch. +type ICreate_model_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE_SYMBOL() antlr.TerminalNode + MODEL_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + Opt_or_replace() IOpt_or_replaceContext + Opt_create_scope() IOpt_create_scopeContext + Opt_if_not_exists() IOpt_if_not_existsContext + Opt_input_output_clause() IOpt_input_output_clauseContext + Opt_transform_clause() IOpt_transform_clauseContext + Remote_with_connection_clause() IRemote_with_connection_clauseContext + Opt_options_list() IOpt_options_listContext + Opt_as_query_or_aliased_query_list() IOpt_as_query_or_aliased_query_listContext + + // IsCreate_model_statementContext differentiates from other interfaces. + IsCreate_model_statementContext() +} + +type Create_model_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_model_statementContext() *Create_model_statementContext { + var p = new(Create_model_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_model_statement + return p +} + +func InitEmptyCreate_model_statementContext(p *Create_model_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_model_statement +} + +func (*Create_model_statementContext) IsCreate_model_statementContext() {} + +func NewCreate_model_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_model_statementContext { + var p = new(Create_model_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_create_model_statement + + return p +} + +func (s *Create_model_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_model_statementContext) CREATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCREATE_SYMBOL, 0) +} + +func (s *Create_model_statementContext) MODEL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMODEL_SYMBOL, 0) +} + +func (s *Create_model_statementContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Create_model_statementContext) Opt_or_replace() IOpt_or_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_replaceContext) +} + +func (s *Create_model_statementContext) Opt_create_scope() IOpt_create_scopeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_create_scopeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_create_scopeContext) +} + +func (s *Create_model_statementContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *Create_model_statementContext) Opt_input_output_clause() IOpt_input_output_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_input_output_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_input_output_clauseContext) +} + +func (s *Create_model_statementContext) Opt_transform_clause() IOpt_transform_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_transform_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_transform_clauseContext) +} + +func (s *Create_model_statementContext) Remote_with_connection_clause() IRemote_with_connection_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRemote_with_connection_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRemote_with_connection_clauseContext) +} + +func (s *Create_model_statementContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Create_model_statementContext) Opt_as_query_or_aliased_query_list() IOpt_as_query_or_aliased_query_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_as_query_or_aliased_query_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_as_query_or_aliased_query_listContext) +} + +func (s *Create_model_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_model_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_model_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCreate_model_statement(s) + } +} + +func (s *Create_model_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCreate_model_statement(s) + } +} + +func (s *Create_model_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCreate_model_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Create_model_statement() (localctx ICreate_model_statementContext) { + localctx = NewCreate_model_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 250, GoogleSQLParserRULE_create_model_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2452) + p.Match(GoogleSQLParserCREATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2454) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOR_SYMBOL { + { + p.SetState(2453) + p.Opt_or_replace() + } + + } + p.SetState(2457) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-226)) & ^0x3f) == 0 && ((int64(1)<<(_la-226))&105553116266529) != 0 { + { + p.SetState(2456) + p.Opt_create_scope() + } + + } + { + p.SetState(2459) + p.Match(GoogleSQLParserMODEL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2461) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(2460) + p.Opt_if_not_exists() + } + + } + { + p.SetState(2463) + p.Path_expression() + } + p.SetState(2465) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserINPUT_SYMBOL { + { + p.SetState(2464) + p.Opt_input_output_clause() + } + + } + p.SetState(2468) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserTRANSFORM_SYMBOL { + { + p.SetState(2467) + p.Opt_transform_clause() + } + + } + p.SetState(2471) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWITH_SYMBOL || _la == GoogleSQLParserREMOTE_SYMBOL { + { + p.SetState(2470) + p.Remote_with_connection_clause() + } + + } + p.SetState(2474) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(2473) + p.Opt_options_list() + } + + } + p.SetState(2477) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(2476) + p.Opt_as_query_or_aliased_query_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_input_output_clauseContext is an interface to support dynamic dispatch. +type IOpt_input_output_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INPUT_SYMBOL() antlr.TerminalNode + AllTable_element_list() []ITable_element_listContext + Table_element_list(i int) ITable_element_listContext + OUTPUT_SYMBOL() antlr.TerminalNode + + // IsOpt_input_output_clauseContext differentiates from other interfaces. + IsOpt_input_output_clauseContext() +} + +type Opt_input_output_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_input_output_clauseContext() *Opt_input_output_clauseContext { + var p = new(Opt_input_output_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_input_output_clause + return p +} + +func InitEmptyOpt_input_output_clauseContext(p *Opt_input_output_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_input_output_clause +} + +func (*Opt_input_output_clauseContext) IsOpt_input_output_clauseContext() {} + +func NewOpt_input_output_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_input_output_clauseContext { + var p = new(Opt_input_output_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_input_output_clause + + return p +} + +func (s *Opt_input_output_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_input_output_clauseContext) INPUT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINPUT_SYMBOL, 0) +} + +func (s *Opt_input_output_clauseContext) AllTable_element_list() []ITable_element_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_element_listContext); ok { + len++ + } + } + + tst := make([]ITable_element_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_element_listContext); ok { + tst[i] = t.(ITable_element_listContext) + i++ + } + } + + return tst +} + +func (s *Opt_input_output_clauseContext) Table_element_list(i int) ITable_element_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_element_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_element_listContext) +} + +func (s *Opt_input_output_clauseContext) OUTPUT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOUTPUT_SYMBOL, 0) +} + +func (s *Opt_input_output_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_input_output_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_input_output_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_input_output_clause(s) + } +} + +func (s *Opt_input_output_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_input_output_clause(s) + } +} + +func (s *Opt_input_output_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_input_output_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_input_output_clause() (localctx IOpt_input_output_clauseContext) { + localctx = NewOpt_input_output_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 252, GoogleSQLParserRULE_opt_input_output_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2479) + p.Match(GoogleSQLParserINPUT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2480) + p.Table_element_list() + } + { + p.SetState(2481) + p.Match(GoogleSQLParserOUTPUT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2482) + p.Table_element_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_transform_clauseContext is an interface to support dynamic dispatch. +type IOpt_transform_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRANSFORM_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + Select_list() ISelect_listContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsOpt_transform_clauseContext differentiates from other interfaces. + IsOpt_transform_clauseContext() +} + +type Opt_transform_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_transform_clauseContext() *Opt_transform_clauseContext { + var p = new(Opt_transform_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_transform_clause + return p +} + +func InitEmptyOpt_transform_clauseContext(p *Opt_transform_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_transform_clause +} + +func (*Opt_transform_clauseContext) IsOpt_transform_clauseContext() {} + +func NewOpt_transform_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_transform_clauseContext { + var p = new(Opt_transform_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_transform_clause + + return p +} + +func (s *Opt_transform_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_transform_clauseContext) TRANSFORM_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTRANSFORM_SYMBOL, 0) +} + +func (s *Opt_transform_clauseContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Opt_transform_clauseContext) Select_list() ISelect_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_listContext) +} + +func (s *Opt_transform_clauseContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Opt_transform_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_transform_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_transform_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_transform_clause(s) + } +} + +func (s *Opt_transform_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_transform_clause(s) + } +} + +func (s *Opt_transform_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_transform_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_transform_clause() (localctx IOpt_transform_clauseContext) { + localctx = NewOpt_transform_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 254, GoogleSQLParserRULE_opt_transform_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2484) + p.Match(GoogleSQLParserTRANSFORM_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2485) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2486) + p.Select_list() + } + { + p.SetState(2487) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_as_query_or_aliased_query_listContext is an interface to support dynamic dispatch. +type IOpt_as_query_or_aliased_query_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + As_query() IAs_queryContext + AS_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + Aliased_query_list() IAliased_query_listContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsOpt_as_query_or_aliased_query_listContext differentiates from other interfaces. + IsOpt_as_query_or_aliased_query_listContext() +} + +type Opt_as_query_or_aliased_query_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_as_query_or_aliased_query_listContext() *Opt_as_query_or_aliased_query_listContext { + var p = new(Opt_as_query_or_aliased_query_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_as_query_or_aliased_query_list + return p +} + +func InitEmptyOpt_as_query_or_aliased_query_listContext(p *Opt_as_query_or_aliased_query_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_as_query_or_aliased_query_list +} + +func (*Opt_as_query_or_aliased_query_listContext) IsOpt_as_query_or_aliased_query_listContext() {} + +func NewOpt_as_query_or_aliased_query_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_as_query_or_aliased_query_listContext { + var p = new(Opt_as_query_or_aliased_query_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_as_query_or_aliased_query_list + + return p +} + +func (s *Opt_as_query_or_aliased_query_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_as_query_or_aliased_query_listContext) As_query() IAs_queryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_queryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_queryContext) +} + +func (s *Opt_as_query_or_aliased_query_listContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Opt_as_query_or_aliased_query_listContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Opt_as_query_or_aliased_query_listContext) Aliased_query_list() IAliased_query_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAliased_query_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAliased_query_listContext) +} + +func (s *Opt_as_query_or_aliased_query_listContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Opt_as_query_or_aliased_query_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_as_query_or_aliased_query_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_as_query_or_aliased_query_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_as_query_or_aliased_query_list(s) + } +} + +func (s *Opt_as_query_or_aliased_query_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_as_query_or_aliased_query_list(s) + } +} + +func (s *Opt_as_query_or_aliased_query_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_as_query_or_aliased_query_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_as_query_or_aliased_query_list() (localctx IOpt_as_query_or_aliased_query_listContext) { + localctx = NewOpt_as_query_or_aliased_query_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 256, GoogleSQLParserRULE_opt_as_query_or_aliased_query_list) + p.SetState(2495) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 220, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2489) + p.As_query() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2490) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2491) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2492) + p.Aliased_query_list() + } + { + p.SetState(2493) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAliased_query_listContext is an interface to support dynamic dispatch. +type IAliased_query_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllAliased_query() []IAliased_queryContext + Aliased_query(i int) IAliased_queryContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsAliased_query_listContext differentiates from other interfaces. + IsAliased_query_listContext() +} + +type Aliased_query_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAliased_query_listContext() *Aliased_query_listContext { + var p = new(Aliased_query_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_aliased_query_list + return p +} + +func InitEmptyAliased_query_listContext(p *Aliased_query_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_aliased_query_list +} + +func (*Aliased_query_listContext) IsAliased_query_listContext() {} + +func NewAliased_query_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aliased_query_listContext { + var p = new(Aliased_query_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_aliased_query_list + + return p +} + +func (s *Aliased_query_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Aliased_query_listContext) AllAliased_query() []IAliased_queryContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAliased_queryContext); ok { + len++ + } + } + + tst := make([]IAliased_queryContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAliased_queryContext); ok { + tst[i] = t.(IAliased_queryContext) + i++ + } + } + + return tst +} + +func (s *Aliased_query_listContext) Aliased_query(i int) IAliased_queryContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAliased_queryContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAliased_queryContext) +} + +func (s *Aliased_query_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Aliased_query_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Aliased_query_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Aliased_query_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Aliased_query_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterAliased_query_list(s) + } +} + +func (s *Aliased_query_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitAliased_query_list(s) + } +} + +func (s *Aliased_query_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitAliased_query_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Aliased_query_list() (localctx IAliased_query_listContext) { + localctx = NewAliased_query_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 258, GoogleSQLParserRULE_aliased_query_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2497) + p.Aliased_query() + } + p.SetState(2502) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(2498) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2499) + p.Aliased_query() + } + + p.SetState(2504) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAs_queryContext is an interface to support dynamic dispatch. +type IAs_queryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AS_SYMBOL() antlr.TerminalNode + Query() IQueryContext + + // IsAs_queryContext differentiates from other interfaces. + IsAs_queryContext() +} + +type As_queryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAs_queryContext() *As_queryContext { + var p = new(As_queryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_as_query + return p +} + +func InitEmptyAs_queryContext(p *As_queryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_as_query +} + +func (*As_queryContext) IsAs_queryContext() {} + +func NewAs_queryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *As_queryContext { + var p = new(As_queryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_as_query + + return p +} + +func (s *As_queryContext) GetParser() antlr.Parser { return s.parser } + +func (s *As_queryContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *As_queryContext) Query() IQueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryContext) +} + +func (s *As_queryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *As_queryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *As_queryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterAs_query(s) + } +} + +func (s *As_queryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitAs_query(s) + } +} + +func (s *As_queryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitAs_query(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) As_query() (localctx IAs_queryContext) { + localctx = NewAs_queryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 260, GoogleSQLParserRULE_as_query) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2505) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2506) + p.Query() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_external_table_function_statementContext is an interface to support dynamic dispatch. +type ICreate_external_table_function_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE_SYMBOL() antlr.TerminalNode + EXTERNAL_SYMBOL() antlr.TerminalNode + TABLE_SYMBOL() antlr.TerminalNode + FUNCTION_SYMBOL() antlr.TerminalNode + Opt_or_replace() IOpt_or_replaceContext + Opt_create_scope() IOpt_create_scopeContext + + // IsCreate_external_table_function_statementContext differentiates from other interfaces. + IsCreate_external_table_function_statementContext() +} + +type Create_external_table_function_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_external_table_function_statementContext() *Create_external_table_function_statementContext { + var p = new(Create_external_table_function_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_external_table_function_statement + return p +} + +func InitEmptyCreate_external_table_function_statementContext(p *Create_external_table_function_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_external_table_function_statement +} + +func (*Create_external_table_function_statementContext) IsCreate_external_table_function_statementContext() { +} + +func NewCreate_external_table_function_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_external_table_function_statementContext { + var p = new(Create_external_table_function_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_create_external_table_function_statement + + return p +} + +func (s *Create_external_table_function_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_external_table_function_statementContext) CREATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCREATE_SYMBOL, 0) +} + +func (s *Create_external_table_function_statementContext) EXTERNAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXTERNAL_SYMBOL, 0) +} + +func (s *Create_external_table_function_statementContext) TABLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTABLE_SYMBOL, 0) +} + +func (s *Create_external_table_function_statementContext) FUNCTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFUNCTION_SYMBOL, 0) +} + +func (s *Create_external_table_function_statementContext) Opt_or_replace() IOpt_or_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_replaceContext) +} + +func (s *Create_external_table_function_statementContext) Opt_create_scope() IOpt_create_scopeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_create_scopeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_create_scopeContext) +} + +func (s *Create_external_table_function_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_external_table_function_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_external_table_function_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCreate_external_table_function_statement(s) + } +} + +func (s *Create_external_table_function_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCreate_external_table_function_statement(s) + } +} + +func (s *Create_external_table_function_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCreate_external_table_function_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Create_external_table_function_statement() (localctx ICreate_external_table_function_statementContext) { + localctx = NewCreate_external_table_function_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 262, GoogleSQLParserRULE_create_external_table_function_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2508) + p.Match(GoogleSQLParserCREATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2510) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOR_SYMBOL { + { + p.SetState(2509) + p.Opt_or_replace() + } + + } + p.SetState(2513) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-226)) & ^0x3f) == 0 && ((int64(1)<<(_la-226))&105553116266529) != 0 { + { + p.SetState(2512) + p.Opt_create_scope() + } + + } + { + p.SetState(2515) + p.Match(GoogleSQLParserEXTERNAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2516) + p.Match(GoogleSQLParserTABLE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2517) + p.Match(GoogleSQLParserFUNCTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.NotifyErrorListeners("Syntax error: CREATE EXTERNAL TABLE FUNCTION is not supported", nil, nil) + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_external_table_statementContext is an interface to support dynamic dispatch. +type ICreate_external_table_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE_SYMBOL() antlr.TerminalNode + EXTERNAL_SYMBOL() antlr.TerminalNode + TABLE_SYMBOL() antlr.TerminalNode + Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext + Opt_or_replace() IOpt_or_replaceContext + Opt_create_scope() IOpt_create_scopeContext + Opt_if_not_exists() IOpt_if_not_existsContext + Table_element_list() ITable_element_listContext + Opt_like_path_expression() IOpt_like_path_expressionContext + Opt_default_collate_clause() IOpt_default_collate_clauseContext + Opt_external_table_with_clauses() IOpt_external_table_with_clausesContext + Opt_options_list() IOpt_options_listContext + + // IsCreate_external_table_statementContext differentiates from other interfaces. + IsCreate_external_table_statementContext() +} + +type Create_external_table_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_external_table_statementContext() *Create_external_table_statementContext { + var p = new(Create_external_table_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_external_table_statement + return p +} + +func InitEmptyCreate_external_table_statementContext(p *Create_external_table_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_external_table_statement +} + +func (*Create_external_table_statementContext) IsCreate_external_table_statementContext() {} + +func NewCreate_external_table_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_external_table_statementContext { + var p = new(Create_external_table_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_create_external_table_statement + + return p +} + +func (s *Create_external_table_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_external_table_statementContext) CREATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCREATE_SYMBOL, 0) +} + +func (s *Create_external_table_statementContext) EXTERNAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXTERNAL_SYMBOL, 0) +} + +func (s *Create_external_table_statementContext) TABLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTABLE_SYMBOL, 0) +} + +func (s *Create_external_table_statementContext) Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_dashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_dashed_path_expressionContext) +} + +func (s *Create_external_table_statementContext) Opt_or_replace() IOpt_or_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_replaceContext) +} + +func (s *Create_external_table_statementContext) Opt_create_scope() IOpt_create_scopeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_create_scopeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_create_scopeContext) +} + +func (s *Create_external_table_statementContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *Create_external_table_statementContext) Table_element_list() ITable_element_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_element_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_element_listContext) +} + +func (s *Create_external_table_statementContext) Opt_like_path_expression() IOpt_like_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_like_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_like_path_expressionContext) +} + +func (s *Create_external_table_statementContext) Opt_default_collate_clause() IOpt_default_collate_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_default_collate_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_default_collate_clauseContext) +} + +func (s *Create_external_table_statementContext) Opt_external_table_with_clauses() IOpt_external_table_with_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_external_table_with_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_external_table_with_clausesContext) +} + +func (s *Create_external_table_statementContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Create_external_table_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_external_table_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_external_table_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCreate_external_table_statement(s) + } +} + +func (s *Create_external_table_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCreate_external_table_statement(s) + } +} + +func (s *Create_external_table_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCreate_external_table_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Create_external_table_statement() (localctx ICreate_external_table_statementContext) { + localctx = NewCreate_external_table_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 264, GoogleSQLParserRULE_create_external_table_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2520) + p.Match(GoogleSQLParserCREATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2522) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOR_SYMBOL { + { + p.SetState(2521) + p.Opt_or_replace() + } + + } + p.SetState(2525) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-226)) & ^0x3f) == 0 && ((int64(1)<<(_la-226))&105553116266529) != 0 { + { + p.SetState(2524) + p.Opt_create_scope() + } + + } + { + p.SetState(2527) + p.Match(GoogleSQLParserEXTERNAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2528) + p.Match(GoogleSQLParserTABLE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2530) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(2529) + p.Opt_if_not_exists() + } + + } + { + p.SetState(2532) + p.Maybe_dashed_path_expression() + } + p.SetState(2534) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL { + { + p.SetState(2533) + p.Table_element_list() + } + + } + p.SetState(2537) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLIKE_SYMBOL { + { + p.SetState(2536) + p.Opt_like_path_expression() + } + + } + p.SetState(2540) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserDEFAULT_SYMBOL { + { + p.SetState(2539) + p.Opt_default_collate_clause() + } + + } + p.SetState(2543) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWITH_SYMBOL { + { + p.SetState(2542) + p.Opt_external_table_with_clauses() + } + + } + p.SetState(2546) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(2545) + p.Opt_options_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_default_collate_clauseContext is an interface to support dynamic dispatch. +type IOpt_default_collate_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT_SYMBOL() antlr.TerminalNode + Collate_clause() ICollate_clauseContext + + // IsOpt_default_collate_clauseContext differentiates from other interfaces. + IsOpt_default_collate_clauseContext() +} + +type Opt_default_collate_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_default_collate_clauseContext() *Opt_default_collate_clauseContext { + var p = new(Opt_default_collate_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_default_collate_clause + return p +} + +func InitEmptyOpt_default_collate_clauseContext(p *Opt_default_collate_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_default_collate_clause +} + +func (*Opt_default_collate_clauseContext) IsOpt_default_collate_clauseContext() {} + +func NewOpt_default_collate_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_default_collate_clauseContext { + var p = new(Opt_default_collate_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_default_collate_clause + + return p +} + +func (s *Opt_default_collate_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_default_collate_clauseContext) DEFAULT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDEFAULT_SYMBOL, 0) +} + +func (s *Opt_default_collate_clauseContext) Collate_clause() ICollate_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollate_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollate_clauseContext) +} + +func (s *Opt_default_collate_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_default_collate_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_default_collate_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_default_collate_clause(s) + } +} + +func (s *Opt_default_collate_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_default_collate_clause(s) + } +} + +func (s *Opt_default_collate_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_default_collate_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_default_collate_clause() (localctx IOpt_default_collate_clauseContext) { + localctx = NewOpt_default_collate_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 266, GoogleSQLParserRULE_opt_default_collate_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2548) + p.Match(GoogleSQLParserDEFAULT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2549) + p.Collate_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_like_path_expressionContext is an interface to support dynamic dispatch. +type IOpt_like_path_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LIKE_SYMBOL() antlr.TerminalNode + Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext + + // IsOpt_like_path_expressionContext differentiates from other interfaces. + IsOpt_like_path_expressionContext() +} + +type Opt_like_path_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_like_path_expressionContext() *Opt_like_path_expressionContext { + var p = new(Opt_like_path_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_like_path_expression + return p +} + +func InitEmptyOpt_like_path_expressionContext(p *Opt_like_path_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_like_path_expression +} + +func (*Opt_like_path_expressionContext) IsOpt_like_path_expressionContext() {} + +func NewOpt_like_path_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_like_path_expressionContext { + var p = new(Opt_like_path_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_like_path_expression + + return p +} + +func (s *Opt_like_path_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_like_path_expressionContext) LIKE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLIKE_SYMBOL, 0) +} + +func (s *Opt_like_path_expressionContext) Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_dashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_dashed_path_expressionContext) +} + +func (s *Opt_like_path_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_like_path_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_like_path_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_like_path_expression(s) + } +} + +func (s *Opt_like_path_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_like_path_expression(s) + } +} + +func (s *Opt_like_path_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_like_path_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_like_path_expression() (localctx IOpt_like_path_expressionContext) { + localctx = NewOpt_like_path_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 268, GoogleSQLParserRULE_opt_like_path_expression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2551) + p.Match(GoogleSQLParserLIKE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2552) + p.Maybe_dashed_path_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_row_access_policy_statementContext is an interface to support dynamic dispatch. +type ICreate_row_access_policy_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE_SYMBOL() antlr.TerminalNode + ROW_SYMBOL() antlr.TerminalNode + POLICY_SYMBOL() antlr.TerminalNode + ON_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + Filter_using_clause() IFilter_using_clauseContext + Opt_or_replace() IOpt_or_replaceContext + ACCESS_SYMBOL() antlr.TerminalNode + Opt_if_not_exists() IOpt_if_not_existsContext + Identifier() IIdentifierContext + Create_row_access_policy_grant_to_clause() ICreate_row_access_policy_grant_to_clauseContext + + // IsCreate_row_access_policy_statementContext differentiates from other interfaces. + IsCreate_row_access_policy_statementContext() +} + +type Create_row_access_policy_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_row_access_policy_statementContext() *Create_row_access_policy_statementContext { + var p = new(Create_row_access_policy_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_row_access_policy_statement + return p +} + +func InitEmptyCreate_row_access_policy_statementContext(p *Create_row_access_policy_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_row_access_policy_statement +} + +func (*Create_row_access_policy_statementContext) IsCreate_row_access_policy_statementContext() {} + +func NewCreate_row_access_policy_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_row_access_policy_statementContext { + var p = new(Create_row_access_policy_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_create_row_access_policy_statement + + return p +} + +func (s *Create_row_access_policy_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_row_access_policy_statementContext) CREATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCREATE_SYMBOL, 0) +} + +func (s *Create_row_access_policy_statementContext) ROW_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserROW_SYMBOL, 0) +} + +func (s *Create_row_access_policy_statementContext) POLICY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPOLICY_SYMBOL, 0) +} + +func (s *Create_row_access_policy_statementContext) ON_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserON_SYMBOL, 0) +} + +func (s *Create_row_access_policy_statementContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Create_row_access_policy_statementContext) Filter_using_clause() IFilter_using_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilter_using_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilter_using_clauseContext) +} + +func (s *Create_row_access_policy_statementContext) Opt_or_replace() IOpt_or_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_replaceContext) +} + +func (s *Create_row_access_policy_statementContext) ACCESS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserACCESS_SYMBOL, 0) +} + +func (s *Create_row_access_policy_statementContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *Create_row_access_policy_statementContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Create_row_access_policy_statementContext) Create_row_access_policy_grant_to_clause() ICreate_row_access_policy_grant_to_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_row_access_policy_grant_to_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_row_access_policy_grant_to_clauseContext) +} + +func (s *Create_row_access_policy_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_row_access_policy_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_row_access_policy_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCreate_row_access_policy_statement(s) + } +} + +func (s *Create_row_access_policy_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCreate_row_access_policy_statement(s) + } +} + +func (s *Create_row_access_policy_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCreate_row_access_policy_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Create_row_access_policy_statement() (localctx ICreate_row_access_policy_statementContext) { + localctx = NewCreate_row_access_policy_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 270, GoogleSQLParserRULE_create_row_access_policy_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2554) + p.Match(GoogleSQLParserCREATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2556) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOR_SYMBOL { + { + p.SetState(2555) + p.Opt_or_replace() + } + + } + { + p.SetState(2558) + p.Match(GoogleSQLParserROW_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2560) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserACCESS_SYMBOL { + { + p.SetState(2559) + p.Match(GoogleSQLParserACCESS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2562) + p.Match(GoogleSQLParserPOLICY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2564) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(2563) + p.Opt_if_not_exists() + } + + } + p.SetState(2567) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-74)) & ^0x3f) == 0 && ((int64(1)<<(_la-74))&-106523215214079) != 0) || ((int64((_la-138)) & ^0x3f) == 0 && ((int64(1)<<(_la-138))&-1) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-36028797018963969) != 0) || ((int64((_la-266)) & ^0x3f) == 0 && ((int64(1)<<(_la-266))&536870911) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&33488865) != 0) { + { + p.SetState(2566) + p.Identifier() + } + + } + { + p.SetState(2569) + p.Match(GoogleSQLParserON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2570) + p.Path_expression() + } + p.SetState(2572) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserGRANT_SYMBOL || _la == GoogleSQLParserTO_SYMBOL { + { + p.SetState(2571) + p.Create_row_access_policy_grant_to_clause() + } + + } + { + p.SetState(2574) + p.Filter_using_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFilter_using_clauseContext is an interface to support dynamic dispatch. +type IFilter_using_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + FILTER_SYMBOL() antlr.TerminalNode + + // IsFilter_using_clauseContext differentiates from other interfaces. + IsFilter_using_clauseContext() +} + +type Filter_using_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFilter_using_clauseContext() *Filter_using_clauseContext { + var p = new(Filter_using_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_filter_using_clause + return p +} + +func InitEmptyFilter_using_clauseContext(p *Filter_using_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_filter_using_clause +} + +func (*Filter_using_clauseContext) IsFilter_using_clauseContext() {} + +func NewFilter_using_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Filter_using_clauseContext { + var p = new(Filter_using_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_filter_using_clause + + return p +} + +func (s *Filter_using_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Filter_using_clauseContext) USING_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUSING_SYMBOL, 0) +} + +func (s *Filter_using_clauseContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Filter_using_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Filter_using_clauseContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Filter_using_clauseContext) FILTER_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFILTER_SYMBOL, 0) +} + +func (s *Filter_using_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Filter_using_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Filter_using_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterFilter_using_clause(s) + } +} + +func (s *Filter_using_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitFilter_using_clause(s) + } +} + +func (s *Filter_using_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitFilter_using_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Filter_using_clause() (localctx IFilter_using_clauseContext) { + localctx = NewFilter_using_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 272, GoogleSQLParserRULE_filter_using_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(2577) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserFILTER_SYMBOL { + { + p.SetState(2576) + p.Match(GoogleSQLParserFILTER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2579) + p.Match(GoogleSQLParserUSING_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2580) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2581) + p.expression(0) + } + { + p.SetState(2582) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_row_access_policy_grant_to_clauseContext is an interface to support dynamic dispatch. +type ICreate_row_access_policy_grant_to_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Grant_to_clause() IGrant_to_clauseContext + TO_SYMBOL() antlr.TerminalNode + Grantee_list() IGrantee_listContext + + // IsCreate_row_access_policy_grant_to_clauseContext differentiates from other interfaces. + IsCreate_row_access_policy_grant_to_clauseContext() +} + +type Create_row_access_policy_grant_to_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_row_access_policy_grant_to_clauseContext() *Create_row_access_policy_grant_to_clauseContext { + var p = new(Create_row_access_policy_grant_to_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_row_access_policy_grant_to_clause + return p +} + +func InitEmptyCreate_row_access_policy_grant_to_clauseContext(p *Create_row_access_policy_grant_to_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_row_access_policy_grant_to_clause +} + +func (*Create_row_access_policy_grant_to_clauseContext) IsCreate_row_access_policy_grant_to_clauseContext() { +} + +func NewCreate_row_access_policy_grant_to_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_row_access_policy_grant_to_clauseContext { + var p = new(Create_row_access_policy_grant_to_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_create_row_access_policy_grant_to_clause + + return p +} + +func (s *Create_row_access_policy_grant_to_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_row_access_policy_grant_to_clauseContext) Grant_to_clause() IGrant_to_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_to_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_to_clauseContext) +} + +func (s *Create_row_access_policy_grant_to_clauseContext) TO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTO_SYMBOL, 0) +} + +func (s *Create_row_access_policy_grant_to_clauseContext) Grantee_list() IGrantee_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_listContext) +} + +func (s *Create_row_access_policy_grant_to_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_row_access_policy_grant_to_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_row_access_policy_grant_to_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCreate_row_access_policy_grant_to_clause(s) + } +} + +func (s *Create_row_access_policy_grant_to_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCreate_row_access_policy_grant_to_clause(s) + } +} + +func (s *Create_row_access_policy_grant_to_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCreate_row_access_policy_grant_to_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Create_row_access_policy_grant_to_clause() (localctx ICreate_row_access_policy_grant_to_clauseContext) { + localctx = NewCreate_row_access_policy_grant_to_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 274, GoogleSQLParserRULE_create_row_access_policy_grant_to_clause) + p.SetState(2587) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserGRANT_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2584) + p.Grant_to_clause() + } + + case GoogleSQLParserTO_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2585) + p.Match(GoogleSQLParserTO_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2586) + p.Grantee_list() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_privilege_restriction_statementContext is an interface to support dynamic dispatch. +type ICreate_privilege_restriction_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE_SYMBOL() antlr.TerminalNode + PRIVILEGE_SYMBOL() antlr.TerminalNode + RESTRICTION_SYMBOL() antlr.TerminalNode + AllON_SYMBOL() []antlr.TerminalNode + ON_SYMBOL(i int) antlr.TerminalNode + Privilege_list() IPrivilege_listContext + Identifier() IIdentifierContext + Path_expression() IPath_expressionContext + Opt_or_replace() IOpt_or_replaceContext + Opt_if_not_exists() IOpt_if_not_existsContext + Restrict_to_clause() IRestrict_to_clauseContext + + // IsCreate_privilege_restriction_statementContext differentiates from other interfaces. + IsCreate_privilege_restriction_statementContext() +} + +type Create_privilege_restriction_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_privilege_restriction_statementContext() *Create_privilege_restriction_statementContext { + var p = new(Create_privilege_restriction_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_privilege_restriction_statement + return p +} + +func InitEmptyCreate_privilege_restriction_statementContext(p *Create_privilege_restriction_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_privilege_restriction_statement +} + +func (*Create_privilege_restriction_statementContext) IsCreate_privilege_restriction_statementContext() { +} + +func NewCreate_privilege_restriction_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_privilege_restriction_statementContext { + var p = new(Create_privilege_restriction_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_create_privilege_restriction_statement + + return p +} + +func (s *Create_privilege_restriction_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_privilege_restriction_statementContext) CREATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCREATE_SYMBOL, 0) +} + +func (s *Create_privilege_restriction_statementContext) PRIVILEGE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPRIVILEGE_SYMBOL, 0) +} + +func (s *Create_privilege_restriction_statementContext) RESTRICTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRESTRICTION_SYMBOL, 0) +} + +func (s *Create_privilege_restriction_statementContext) AllON_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserON_SYMBOL) +} + +func (s *Create_privilege_restriction_statementContext) ON_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserON_SYMBOL, i) +} + +func (s *Create_privilege_restriction_statementContext) Privilege_list() IPrivilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrivilege_listContext) +} + +func (s *Create_privilege_restriction_statementContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Create_privilege_restriction_statementContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Create_privilege_restriction_statementContext) Opt_or_replace() IOpt_or_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_replaceContext) +} + +func (s *Create_privilege_restriction_statementContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *Create_privilege_restriction_statementContext) Restrict_to_clause() IRestrict_to_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRestrict_to_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRestrict_to_clauseContext) +} + +func (s *Create_privilege_restriction_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_privilege_restriction_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_privilege_restriction_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCreate_privilege_restriction_statement(s) + } +} + +func (s *Create_privilege_restriction_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCreate_privilege_restriction_statement(s) + } +} + +func (s *Create_privilege_restriction_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCreate_privilege_restriction_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Create_privilege_restriction_statement() (localctx ICreate_privilege_restriction_statementContext) { + localctx = NewCreate_privilege_restriction_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 276, GoogleSQLParserRULE_create_privilege_restriction_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2589) + p.Match(GoogleSQLParserCREATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2591) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOR_SYMBOL { + { + p.SetState(2590) + p.Opt_or_replace() + } + + } + { + p.SetState(2593) + p.Match(GoogleSQLParserPRIVILEGE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2594) + p.Match(GoogleSQLParserRESTRICTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2596) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(2595) + p.Opt_if_not_exists() + } + + } + { + p.SetState(2598) + p.Match(GoogleSQLParserON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2599) + p.Privilege_list() + } + { + p.SetState(2600) + p.Match(GoogleSQLParserON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2601) + p.Identifier() + } + { + p.SetState(2602) + p.Path_expression() + } + p.SetState(2604) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserRESTRICT_SYMBOL { + { + p.SetState(2603) + p.Restrict_to_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRestrict_to_clauseContext is an interface to support dynamic dispatch. +type IRestrict_to_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RESTRICT_SYMBOL() antlr.TerminalNode + TO_SYMBOL() antlr.TerminalNode + Possibly_empty_grantee_list() IPossibly_empty_grantee_listContext + + // IsRestrict_to_clauseContext differentiates from other interfaces. + IsRestrict_to_clauseContext() +} + +type Restrict_to_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRestrict_to_clauseContext() *Restrict_to_clauseContext { + var p = new(Restrict_to_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_restrict_to_clause + return p +} + +func InitEmptyRestrict_to_clauseContext(p *Restrict_to_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_restrict_to_clause +} + +func (*Restrict_to_clauseContext) IsRestrict_to_clauseContext() {} + +func NewRestrict_to_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Restrict_to_clauseContext { + var p = new(Restrict_to_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_restrict_to_clause + + return p +} + +func (s *Restrict_to_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Restrict_to_clauseContext) RESTRICT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRESTRICT_SYMBOL, 0) +} + +func (s *Restrict_to_clauseContext) TO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTO_SYMBOL, 0) +} + +func (s *Restrict_to_clauseContext) Possibly_empty_grantee_list() IPossibly_empty_grantee_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPossibly_empty_grantee_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPossibly_empty_grantee_listContext) +} + +func (s *Restrict_to_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Restrict_to_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Restrict_to_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterRestrict_to_clause(s) + } +} + +func (s *Restrict_to_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitRestrict_to_clause(s) + } +} + +func (s *Restrict_to_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitRestrict_to_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Restrict_to_clause() (localctx IRestrict_to_clauseContext) { + localctx = NewRestrict_to_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 278, GoogleSQLParserRULE_restrict_to_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2606) + p.Match(GoogleSQLParserRESTRICT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2607) + p.Match(GoogleSQLParserTO_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2608) + p.Possibly_empty_grantee_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPossibly_empty_grantee_listContext is an interface to support dynamic dispatch. +type IPossibly_empty_grantee_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + RR_BRACKET_SYMBOL() antlr.TerminalNode + AllString_literal_or_parameter() []IString_literal_or_parameterContext + String_literal_or_parameter(i int) IString_literal_or_parameterContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsPossibly_empty_grantee_listContext differentiates from other interfaces. + IsPossibly_empty_grantee_listContext() +} + +type Possibly_empty_grantee_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPossibly_empty_grantee_listContext() *Possibly_empty_grantee_listContext { + var p = new(Possibly_empty_grantee_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_possibly_empty_grantee_list + return p +} + +func InitEmptyPossibly_empty_grantee_listContext(p *Possibly_empty_grantee_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_possibly_empty_grantee_list +} + +func (*Possibly_empty_grantee_listContext) IsPossibly_empty_grantee_listContext() {} + +func NewPossibly_empty_grantee_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Possibly_empty_grantee_listContext { + var p = new(Possibly_empty_grantee_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_possibly_empty_grantee_list + + return p +} + +func (s *Possibly_empty_grantee_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Possibly_empty_grantee_listContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Possibly_empty_grantee_listContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Possibly_empty_grantee_listContext) AllString_literal_or_parameter() []IString_literal_or_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IString_literal_or_parameterContext); ok { + len++ + } + } + + tst := make([]IString_literal_or_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IString_literal_or_parameterContext); ok { + tst[i] = t.(IString_literal_or_parameterContext) + i++ + } + } + + return tst +} + +func (s *Possibly_empty_grantee_listContext) String_literal_or_parameter(i int) IString_literal_or_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_literal_or_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IString_literal_or_parameterContext) +} + +func (s *Possibly_empty_grantee_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Possibly_empty_grantee_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Possibly_empty_grantee_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Possibly_empty_grantee_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Possibly_empty_grantee_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPossibly_empty_grantee_list(s) + } +} + +func (s *Possibly_empty_grantee_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPossibly_empty_grantee_list(s) + } +} + +func (s *Possibly_empty_grantee_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPossibly_empty_grantee_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Possibly_empty_grantee_list() (localctx IPossibly_empty_grantee_listContext) { + localctx = NewPossibly_empty_grantee_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 280, GoogleSQLParserRULE_possibly_empty_grantee_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2610) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2619) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&17652315586560) != 0 { + { + p.SetState(2611) + p.String_literal_or_parameter() + } + p.SetState(2616) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(2612) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2613) + p.String_literal_or_parameter() + } + + p.SetState(2618) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(2621) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_index_statementContext is an interface to support dynamic dispatch. +type ICreate_index_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE_SYMBOL() antlr.TerminalNode + INDEX_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + On_path_expression() IOn_path_expressionContext + Index_order_by_and_options() IIndex_order_by_and_optionsContext + Opt_or_replace() IOpt_or_replaceContext + UNIQUE_SYMBOL() antlr.TerminalNode + Opt_spanner_null_filtered() IOpt_spanner_null_filteredContext + Index_type() IIndex_typeContext + Opt_if_not_exists() IOpt_if_not_existsContext + As_alias() IAs_aliasContext + Index_unnest_expression_list() IIndex_unnest_expression_listContext + Index_storing_list() IIndex_storing_listContext + Opt_create_index_statement_suffix() IOpt_create_index_statement_suffixContext + + // IsCreate_index_statementContext differentiates from other interfaces. + IsCreate_index_statementContext() +} + +type Create_index_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_index_statementContext() *Create_index_statementContext { + var p = new(Create_index_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_index_statement + return p +} + +func InitEmptyCreate_index_statementContext(p *Create_index_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_index_statement +} + +func (*Create_index_statementContext) IsCreate_index_statementContext() {} + +func NewCreate_index_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_index_statementContext { + var p = new(Create_index_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_create_index_statement + + return p +} + +func (s *Create_index_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_index_statementContext) CREATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCREATE_SYMBOL, 0) +} + +func (s *Create_index_statementContext) INDEX_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINDEX_SYMBOL, 0) +} + +func (s *Create_index_statementContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Create_index_statementContext) On_path_expression() IOn_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_path_expressionContext) +} + +func (s *Create_index_statementContext) Index_order_by_and_options() IIndex_order_by_and_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_order_by_and_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_order_by_and_optionsContext) +} + +func (s *Create_index_statementContext) Opt_or_replace() IOpt_or_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_replaceContext) +} + +func (s *Create_index_statementContext) UNIQUE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUNIQUE_SYMBOL, 0) +} + +func (s *Create_index_statementContext) Opt_spanner_null_filtered() IOpt_spanner_null_filteredContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_spanner_null_filteredContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_spanner_null_filteredContext) +} + +func (s *Create_index_statementContext) Index_type() IIndex_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_typeContext) +} + +func (s *Create_index_statementContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *Create_index_statementContext) As_alias() IAs_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_aliasContext) +} + +func (s *Create_index_statementContext) Index_unnest_expression_list() IIndex_unnest_expression_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_unnest_expression_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_unnest_expression_listContext) +} + +func (s *Create_index_statementContext) Index_storing_list() IIndex_storing_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_storing_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_storing_listContext) +} + +func (s *Create_index_statementContext) Opt_create_index_statement_suffix() IOpt_create_index_statement_suffixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_create_index_statement_suffixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_create_index_statement_suffixContext) +} + +func (s *Create_index_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_index_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_index_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCreate_index_statement(s) + } +} + +func (s *Create_index_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCreate_index_statement(s) + } +} + +func (s *Create_index_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCreate_index_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Create_index_statement() (localctx ICreate_index_statementContext) { + localctx = NewCreate_index_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 282, GoogleSQLParserRULE_create_index_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2623) + p.Match(GoogleSQLParserCREATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2625) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOR_SYMBOL { + { + p.SetState(2624) + p.Opt_or_replace() + } + + } + p.SetState(2628) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserUNIQUE_SYMBOL { + { + p.SetState(2627) + p.Match(GoogleSQLParserUNIQUE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2631) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserNULL_FILTERED_SYMBOL { + { + p.SetState(2630) + p.Opt_spanner_null_filtered() + } + + } + p.SetState(2634) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserSEARCH_SYMBOL || _la == GoogleSQLParserVECTOR_SYMBOL { + { + p.SetState(2633) + p.Index_type() + } + + } + { + p.SetState(2636) + p.Match(GoogleSQLParserINDEX_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2638) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(2637) + p.Opt_if_not_exists() + } + + } + { + p.SetState(2640) + p.Path_expression() + } + { + p.SetState(2641) + p.On_path_expression() + } + p.SetState(2643) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-58)) & ^0x3f) == 0 && ((int64(1)<<(_la-58))&-6981105432269881343) != 0) || ((int64((_la-122)) & ^0x3f) == 0 && ((int64(1)<<(_la-122))&-1) != 0) || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&-1) != 0) || ((int64((_la-250)) & ^0x3f) == 0 && ((int64(1)<<(_la-250))&35184372088703) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&33488865) != 0) { + { + p.SetState(2642) + p.As_alias() + } + + } + p.SetState(2646) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserUNNEST_SYMBOL { + { + p.SetState(2645) + p.Index_unnest_expression_list() + } + + } + { + p.SetState(2648) + p.Index_order_by_and_options() + } + p.SetState(2650) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserSTORING_SYMBOL { + { + p.SetState(2649) + p.Index_storing_list() + } + + } + p.SetState(2653) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCOMMA_SYMBOL || _la == GoogleSQLParserOPTIONS_SYMBOL || _la == GoogleSQLParserPARTITION_SYMBOL { + { + p.SetState(2652) + p.Opt_create_index_statement_suffix() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_create_index_statement_suffixContext is an interface to support dynamic dispatch. +type IOpt_create_index_statement_suffixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Partition_by_clause_prefix_no_hint() IPartition_by_clause_prefix_no_hintContext + Opt_options_list() IOpt_options_listContext + Spanner_index_interleave_clause() ISpanner_index_interleave_clauseContext + + // IsOpt_create_index_statement_suffixContext differentiates from other interfaces. + IsOpt_create_index_statement_suffixContext() +} + +type Opt_create_index_statement_suffixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_create_index_statement_suffixContext() *Opt_create_index_statement_suffixContext { + var p = new(Opt_create_index_statement_suffixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_create_index_statement_suffix + return p +} + +func InitEmptyOpt_create_index_statement_suffixContext(p *Opt_create_index_statement_suffixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_create_index_statement_suffix +} + +func (*Opt_create_index_statement_suffixContext) IsOpt_create_index_statement_suffixContext() {} + +func NewOpt_create_index_statement_suffixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_create_index_statement_suffixContext { + var p = new(Opt_create_index_statement_suffixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_create_index_statement_suffix + + return p +} + +func (s *Opt_create_index_statement_suffixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_create_index_statement_suffixContext) Partition_by_clause_prefix_no_hint() IPartition_by_clause_prefix_no_hintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_by_clause_prefix_no_hintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_by_clause_prefix_no_hintContext) +} + +func (s *Opt_create_index_statement_suffixContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Opt_create_index_statement_suffixContext) Spanner_index_interleave_clause() ISpanner_index_interleave_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpanner_index_interleave_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISpanner_index_interleave_clauseContext) +} + +func (s *Opt_create_index_statement_suffixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_create_index_statement_suffixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_create_index_statement_suffixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_create_index_statement_suffix(s) + } +} + +func (s *Opt_create_index_statement_suffixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_create_index_statement_suffix(s) + } +} + +func (s *Opt_create_index_statement_suffixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_create_index_statement_suffix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_create_index_statement_suffix() (localctx IOpt_create_index_statement_suffixContext) { + localctx = NewOpt_create_index_statement_suffixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 284, GoogleSQLParserRULE_opt_create_index_statement_suffix) + var _la int + + p.SetState(2664) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 255, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2655) + p.Partition_by_clause_prefix_no_hint() + } + p.SetState(2657) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(2656) + p.Opt_options_list() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(2660) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(2659) + p.Opt_options_list() + } + + } + { + p.SetState(2662) + p.Spanner_index_interleave_clause() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2663) + p.Opt_options_list() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISpanner_index_interleave_clauseContext is an interface to support dynamic dispatch. +type ISpanner_index_interleave_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMA_SYMBOL() antlr.TerminalNode + INTERLEAVE_SYMBOL() antlr.TerminalNode + IN_SYMBOL() antlr.TerminalNode + Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext + + // IsSpanner_index_interleave_clauseContext differentiates from other interfaces. + IsSpanner_index_interleave_clauseContext() +} + +type Spanner_index_interleave_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySpanner_index_interleave_clauseContext() *Spanner_index_interleave_clauseContext { + var p = new(Spanner_index_interleave_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_spanner_index_interleave_clause + return p +} + +func InitEmptySpanner_index_interleave_clauseContext(p *Spanner_index_interleave_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_spanner_index_interleave_clause +} + +func (*Spanner_index_interleave_clauseContext) IsSpanner_index_interleave_clauseContext() {} + +func NewSpanner_index_interleave_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Spanner_index_interleave_clauseContext { + var p = new(Spanner_index_interleave_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_spanner_index_interleave_clause + + return p +} + +func (s *Spanner_index_interleave_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Spanner_index_interleave_clauseContext) COMMA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, 0) +} + +func (s *Spanner_index_interleave_clauseContext) INTERLEAVE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINTERLEAVE_SYMBOL, 0) +} + +func (s *Spanner_index_interleave_clauseContext) IN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIN_SYMBOL, 0) +} + +func (s *Spanner_index_interleave_clauseContext) Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_dashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_dashed_path_expressionContext) +} + +func (s *Spanner_index_interleave_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Spanner_index_interleave_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Spanner_index_interleave_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSpanner_index_interleave_clause(s) + } +} + +func (s *Spanner_index_interleave_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSpanner_index_interleave_clause(s) + } +} + +func (s *Spanner_index_interleave_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSpanner_index_interleave_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Spanner_index_interleave_clause() (localctx ISpanner_index_interleave_clauseContext) { + localctx = NewSpanner_index_interleave_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 286, GoogleSQLParserRULE_spanner_index_interleave_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2666) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2667) + p.Match(GoogleSQLParserINTERLEAVE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2668) + p.Match(GoogleSQLParserIN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2669) + p.Maybe_dashed_path_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_storing_listContext is an interface to support dynamic dispatch. +type IIndex_storing_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STORING_SYMBOL() antlr.TerminalNode + Index_storing_expression_list() IIndex_storing_expression_listContext + + // IsIndex_storing_listContext differentiates from other interfaces. + IsIndex_storing_listContext() +} + +type Index_storing_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_storing_listContext() *Index_storing_listContext { + var p = new(Index_storing_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_index_storing_list + return p +} + +func InitEmptyIndex_storing_listContext(p *Index_storing_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_index_storing_list +} + +func (*Index_storing_listContext) IsIndex_storing_listContext() {} + +func NewIndex_storing_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_storing_listContext { + var p = new(Index_storing_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_index_storing_list + + return p +} + +func (s *Index_storing_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_storing_listContext) STORING_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTORING_SYMBOL, 0) +} + +func (s *Index_storing_listContext) Index_storing_expression_list() IIndex_storing_expression_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_storing_expression_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_storing_expression_listContext) +} + +func (s *Index_storing_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_storing_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_storing_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterIndex_storing_list(s) + } +} + +func (s *Index_storing_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitIndex_storing_list(s) + } +} + +func (s *Index_storing_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitIndex_storing_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Index_storing_list() (localctx IIndex_storing_listContext) { + localctx = NewIndex_storing_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 288, GoogleSQLParserRULE_index_storing_list) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2671) + p.Match(GoogleSQLParserSTORING_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2672) + p.Index_storing_expression_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_storing_expression_listContext is an interface to support dynamic dispatch. +type IIndex_storing_expression_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsIndex_storing_expression_listContext differentiates from other interfaces. + IsIndex_storing_expression_listContext() +} + +type Index_storing_expression_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_storing_expression_listContext() *Index_storing_expression_listContext { + var p = new(Index_storing_expression_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_index_storing_expression_list + return p +} + +func InitEmptyIndex_storing_expression_listContext(p *Index_storing_expression_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_index_storing_expression_list +} + +func (*Index_storing_expression_listContext) IsIndex_storing_expression_listContext() {} + +func NewIndex_storing_expression_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_storing_expression_listContext { + var p = new(Index_storing_expression_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_index_storing_expression_list + + return p +} + +func (s *Index_storing_expression_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_storing_expression_listContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Index_storing_expression_listContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Index_storing_expression_listContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Index_storing_expression_listContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Index_storing_expression_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Index_storing_expression_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Index_storing_expression_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_storing_expression_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_storing_expression_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterIndex_storing_expression_list(s) + } +} + +func (s *Index_storing_expression_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitIndex_storing_expression_list(s) + } +} + +func (s *Index_storing_expression_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitIndex_storing_expression_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Index_storing_expression_list() (localctx IIndex_storing_expression_listContext) { + localctx = NewIndex_storing_expression_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 290, GoogleSQLParserRULE_index_storing_expression_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2674) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2675) + p.expression(0) + } + p.SetState(2680) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(2676) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2677) + p.expression(0) + } + + p.SetState(2682) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2683) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_order_by_and_optionsContext is an interface to support dynamic dispatch. +type IIndex_order_by_and_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + AllColumn_ordering_and_options_expr() []IColumn_ordering_and_options_exprContext + Column_ordering_and_options_expr(i int) IColumn_ordering_and_options_exprContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + Index_all_columns() IIndex_all_columnsContext + + // IsIndex_order_by_and_optionsContext differentiates from other interfaces. + IsIndex_order_by_and_optionsContext() +} + +type Index_order_by_and_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_order_by_and_optionsContext() *Index_order_by_and_optionsContext { + var p = new(Index_order_by_and_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_index_order_by_and_options + return p +} + +func InitEmptyIndex_order_by_and_optionsContext(p *Index_order_by_and_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_index_order_by_and_options +} + +func (*Index_order_by_and_optionsContext) IsIndex_order_by_and_optionsContext() {} + +func NewIndex_order_by_and_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_order_by_and_optionsContext { + var p = new(Index_order_by_and_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_index_order_by_and_options + + return p +} + +func (s *Index_order_by_and_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_order_by_and_optionsContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Index_order_by_and_optionsContext) AllColumn_ordering_and_options_expr() []IColumn_ordering_and_options_exprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_ordering_and_options_exprContext); ok { + len++ + } + } + + tst := make([]IColumn_ordering_and_options_exprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_ordering_and_options_exprContext); ok { + tst[i] = t.(IColumn_ordering_and_options_exprContext) + i++ + } + } + + return tst +} + +func (s *Index_order_by_and_optionsContext) Column_ordering_and_options_expr(i int) IColumn_ordering_and_options_exprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_ordering_and_options_exprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_ordering_and_options_exprContext) +} + +func (s *Index_order_by_and_optionsContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Index_order_by_and_optionsContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Index_order_by_and_optionsContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Index_order_by_and_optionsContext) Index_all_columns() IIndex_all_columnsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_all_columnsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_all_columnsContext) +} + +func (s *Index_order_by_and_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_order_by_and_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_order_by_and_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterIndex_order_by_and_options(s) + } +} + +func (s *Index_order_by_and_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitIndex_order_by_and_options(s) + } +} + +func (s *Index_order_by_and_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitIndex_order_by_and_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Index_order_by_and_options() (localctx IIndex_order_by_and_optionsContext) { + localctx = NewIndex_order_by_and_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 292, GoogleSQLParserRULE_index_order_by_and_options) + var _la int + + p.SetState(2697) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 258, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2685) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2686) + p.Column_ordering_and_options_expr() + } + p.SetState(2691) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(2687) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2688) + p.Column_ordering_and_options_expr() + } + + p.SetState(2693) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2694) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2696) + p.Index_all_columns() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_all_columnsContext is an interface to support dynamic dispatch. +type IIndex_all_columnsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + ALL_SYMBOL() antlr.TerminalNode + COLUMNS_SYMBOL() antlr.TerminalNode + RR_BRACKET_SYMBOL() antlr.TerminalNode + Opt_with_column_options() IOpt_with_column_optionsContext + + // IsIndex_all_columnsContext differentiates from other interfaces. + IsIndex_all_columnsContext() +} + +type Index_all_columnsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_all_columnsContext() *Index_all_columnsContext { + var p = new(Index_all_columnsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_index_all_columns + return p +} + +func InitEmptyIndex_all_columnsContext(p *Index_all_columnsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_index_all_columns +} + +func (*Index_all_columnsContext) IsIndex_all_columnsContext() {} + +func NewIndex_all_columnsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_all_columnsContext { + var p = new(Index_all_columnsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_index_all_columns + + return p +} + +func (s *Index_all_columnsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_all_columnsContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Index_all_columnsContext) ALL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserALL_SYMBOL, 0) +} + +func (s *Index_all_columnsContext) COLUMNS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOLUMNS_SYMBOL, 0) +} + +func (s *Index_all_columnsContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Index_all_columnsContext) Opt_with_column_options() IOpt_with_column_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_with_column_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_with_column_optionsContext) +} + +func (s *Index_all_columnsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_all_columnsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_all_columnsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterIndex_all_columns(s) + } +} + +func (s *Index_all_columnsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitIndex_all_columns(s) + } +} + +func (s *Index_all_columnsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitIndex_all_columns(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Index_all_columns() (localctx IIndex_all_columnsContext) { + localctx = NewIndex_all_columnsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 294, GoogleSQLParserRULE_index_all_columns) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2699) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2700) + p.Match(GoogleSQLParserALL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2701) + p.Match(GoogleSQLParserCOLUMNS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2703) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWITH_SYMBOL { + { + p.SetState(2702) + p.Opt_with_column_options() + } + + } + { + p.SetState(2705) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_with_column_optionsContext is an interface to support dynamic dispatch. +type IOpt_with_column_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH_SYMBOL() antlr.TerminalNode + COLUMN_SYMBOL() antlr.TerminalNode + OPTIONS_SYMBOL() antlr.TerminalNode + All_column_column_options() IAll_column_column_optionsContext + + // IsOpt_with_column_optionsContext differentiates from other interfaces. + IsOpt_with_column_optionsContext() +} + +type Opt_with_column_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_with_column_optionsContext() *Opt_with_column_optionsContext { + var p = new(Opt_with_column_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_with_column_options + return p +} + +func InitEmptyOpt_with_column_optionsContext(p *Opt_with_column_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_with_column_options +} + +func (*Opt_with_column_optionsContext) IsOpt_with_column_optionsContext() {} + +func NewOpt_with_column_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_with_column_optionsContext { + var p = new(Opt_with_column_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_with_column_options + + return p +} + +func (s *Opt_with_column_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_with_column_optionsContext) WITH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWITH_SYMBOL, 0) +} + +func (s *Opt_with_column_optionsContext) COLUMN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOLUMN_SYMBOL, 0) +} + +func (s *Opt_with_column_optionsContext) OPTIONS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOPTIONS_SYMBOL, 0) +} + +func (s *Opt_with_column_optionsContext) All_column_column_options() IAll_column_column_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_column_column_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_column_column_optionsContext) +} + +func (s *Opt_with_column_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_with_column_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_with_column_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_with_column_options(s) + } +} + +func (s *Opt_with_column_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_with_column_options(s) + } +} + +func (s *Opt_with_column_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_with_column_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_with_column_options() (localctx IOpt_with_column_optionsContext) { + localctx = NewOpt_with_column_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 296, GoogleSQLParserRULE_opt_with_column_options) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2707) + p.Match(GoogleSQLParserWITH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2708) + p.Match(GoogleSQLParserCOLUMN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2709) + p.Match(GoogleSQLParserOPTIONS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2710) + p.All_column_column_options() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAll_column_column_optionsContext is an interface to support dynamic dispatch. +type IAll_column_column_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + AllColumn_ordering_and_options_expr() []IColumn_ordering_and_options_exprContext + Column_ordering_and_options_expr(i int) IColumn_ordering_and_options_exprContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsAll_column_column_optionsContext differentiates from other interfaces. + IsAll_column_column_optionsContext() +} + +type All_column_column_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAll_column_column_optionsContext() *All_column_column_optionsContext { + var p = new(All_column_column_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_all_column_column_options + return p +} + +func InitEmptyAll_column_column_optionsContext(p *All_column_column_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_all_column_column_options +} + +func (*All_column_column_optionsContext) IsAll_column_column_optionsContext() {} + +func NewAll_column_column_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *All_column_column_optionsContext { + var p = new(All_column_column_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_all_column_column_options + + return p +} + +func (s *All_column_column_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *All_column_column_optionsContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *All_column_column_optionsContext) AllColumn_ordering_and_options_expr() []IColumn_ordering_and_options_exprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_ordering_and_options_exprContext); ok { + len++ + } + } + + tst := make([]IColumn_ordering_and_options_exprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_ordering_and_options_exprContext); ok { + tst[i] = t.(IColumn_ordering_and_options_exprContext) + i++ + } + } + + return tst +} + +func (s *All_column_column_optionsContext) Column_ordering_and_options_expr(i int) IColumn_ordering_and_options_exprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_ordering_and_options_exprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_ordering_and_options_exprContext) +} + +func (s *All_column_column_optionsContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *All_column_column_optionsContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *All_column_column_optionsContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *All_column_column_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *All_column_column_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *All_column_column_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterAll_column_column_options(s) + } +} + +func (s *All_column_column_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitAll_column_column_options(s) + } +} + +func (s *All_column_column_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitAll_column_column_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) All_column_column_options() (localctx IAll_column_column_optionsContext) { + localctx = NewAll_column_column_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 298, GoogleSQLParserRULE_all_column_column_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2712) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2713) + p.Column_ordering_and_options_expr() + } + p.SetState(2718) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(2714) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2715) + p.Column_ordering_and_options_expr() + } + + p.SetState(2720) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2721) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_ordering_and_options_exprContext is an interface to support dynamic dispatch. +type IColumn_ordering_and_options_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + Collate_clause() ICollate_clauseContext + Asc_or_desc() IAsc_or_descContext + Null_order() INull_orderContext + Opt_options_list() IOpt_options_listContext + + // IsColumn_ordering_and_options_exprContext differentiates from other interfaces. + IsColumn_ordering_and_options_exprContext() +} + +type Column_ordering_and_options_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_ordering_and_options_exprContext() *Column_ordering_and_options_exprContext { + var p = new(Column_ordering_and_options_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_column_ordering_and_options_expr + return p +} + +func InitEmptyColumn_ordering_and_options_exprContext(p *Column_ordering_and_options_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_column_ordering_and_options_expr +} + +func (*Column_ordering_and_options_exprContext) IsColumn_ordering_and_options_exprContext() {} + +func NewColumn_ordering_and_options_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_ordering_and_options_exprContext { + var p = new(Column_ordering_and_options_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_column_ordering_and_options_expr + + return p +} + +func (s *Column_ordering_and_options_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_ordering_and_options_exprContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Column_ordering_and_options_exprContext) Collate_clause() ICollate_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollate_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollate_clauseContext) +} + +func (s *Column_ordering_and_options_exprContext) Asc_or_desc() IAsc_or_descContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAsc_or_descContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAsc_or_descContext) +} + +func (s *Column_ordering_and_options_exprContext) Null_order() INull_orderContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INull_orderContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INull_orderContext) +} + +func (s *Column_ordering_and_options_exprContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Column_ordering_and_options_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_ordering_and_options_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_ordering_and_options_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterColumn_ordering_and_options_expr(s) + } +} + +func (s *Column_ordering_and_options_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitColumn_ordering_and_options_expr(s) + } +} + +func (s *Column_ordering_and_options_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitColumn_ordering_and_options_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Column_ordering_and_options_expr() (localctx IColumn_ordering_and_options_exprContext) { + localctx = NewColumn_ordering_and_options_exprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 300, GoogleSQLParserRULE_column_ordering_and_options_expr) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2723) + p.expression(0) + } + p.SetState(2725) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCOLLATE_SYMBOL { + { + p.SetState(2724) + p.Collate_clause() + } + + } + p.SetState(2728) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserASC_SYMBOL || _la == GoogleSQLParserDESC_SYMBOL { + { + p.SetState(2727) + p.Asc_or_desc() + } + + } + p.SetState(2731) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserNULLS_SYMBOL { + { + p.SetState(2730) + p.Null_order() + } + + } + p.SetState(2734) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(2733) + p.Opt_options_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_unnest_expression_listContext is an interface to support dynamic dispatch. +type IIndex_unnest_expression_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllUnnest_expression_with_opt_alias_and_offset() []IUnnest_expression_with_opt_alias_and_offsetContext + Unnest_expression_with_opt_alias_and_offset(i int) IUnnest_expression_with_opt_alias_and_offsetContext + + // IsIndex_unnest_expression_listContext differentiates from other interfaces. + IsIndex_unnest_expression_listContext() +} + +type Index_unnest_expression_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_unnest_expression_listContext() *Index_unnest_expression_listContext { + var p = new(Index_unnest_expression_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_index_unnest_expression_list + return p +} + +func InitEmptyIndex_unnest_expression_listContext(p *Index_unnest_expression_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_index_unnest_expression_list +} + +func (*Index_unnest_expression_listContext) IsIndex_unnest_expression_listContext() {} + +func NewIndex_unnest_expression_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_unnest_expression_listContext { + var p = new(Index_unnest_expression_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_index_unnest_expression_list + + return p +} + +func (s *Index_unnest_expression_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_unnest_expression_listContext) AllUnnest_expression_with_opt_alias_and_offset() []IUnnest_expression_with_opt_alias_and_offsetContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUnnest_expression_with_opt_alias_and_offsetContext); ok { + len++ + } + } + + tst := make([]IUnnest_expression_with_opt_alias_and_offsetContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUnnest_expression_with_opt_alias_and_offsetContext); ok { + tst[i] = t.(IUnnest_expression_with_opt_alias_and_offsetContext) + i++ + } + } + + return tst +} + +func (s *Index_unnest_expression_listContext) Unnest_expression_with_opt_alias_and_offset(i int) IUnnest_expression_with_opt_alias_and_offsetContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnnest_expression_with_opt_alias_and_offsetContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUnnest_expression_with_opt_alias_and_offsetContext) +} + +func (s *Index_unnest_expression_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_unnest_expression_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_unnest_expression_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterIndex_unnest_expression_list(s) + } +} + +func (s *Index_unnest_expression_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitIndex_unnest_expression_list(s) + } +} + +func (s *Index_unnest_expression_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitIndex_unnest_expression_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Index_unnest_expression_list() (localctx IIndex_unnest_expression_listContext) { + localctx = NewIndex_unnest_expression_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 302, GoogleSQLParserRULE_index_unnest_expression_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(2737) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == GoogleSQLParserUNNEST_SYMBOL { + { + p.SetState(2736) + p.Unnest_expression_with_opt_alias_and_offset() + } + + p.SetState(2739) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnnest_expression_with_opt_alias_and_offsetContext is an interface to support dynamic dispatch. +type IUnnest_expression_with_opt_alias_and_offsetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Unnest_expression() IUnnest_expressionContext + As_alias() IAs_aliasContext + Opt_with_offset_and_alias() IOpt_with_offset_and_aliasContext + + // IsUnnest_expression_with_opt_alias_and_offsetContext differentiates from other interfaces. + IsUnnest_expression_with_opt_alias_and_offsetContext() +} + +type Unnest_expression_with_opt_alias_and_offsetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnnest_expression_with_opt_alias_and_offsetContext() *Unnest_expression_with_opt_alias_and_offsetContext { + var p = new(Unnest_expression_with_opt_alias_and_offsetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unnest_expression_with_opt_alias_and_offset + return p +} + +func InitEmptyUnnest_expression_with_opt_alias_and_offsetContext(p *Unnest_expression_with_opt_alias_and_offsetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unnest_expression_with_opt_alias_and_offset +} + +func (*Unnest_expression_with_opt_alias_and_offsetContext) IsUnnest_expression_with_opt_alias_and_offsetContext() { +} + +func NewUnnest_expression_with_opt_alias_and_offsetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unnest_expression_with_opt_alias_and_offsetContext { + var p = new(Unnest_expression_with_opt_alias_and_offsetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_unnest_expression_with_opt_alias_and_offset + + return p +} + +func (s *Unnest_expression_with_opt_alias_and_offsetContext) GetParser() antlr.Parser { + return s.parser +} + +func (s *Unnest_expression_with_opt_alias_and_offsetContext) Unnest_expression() IUnnest_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnnest_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnnest_expressionContext) +} + +func (s *Unnest_expression_with_opt_alias_and_offsetContext) As_alias() IAs_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_aliasContext) +} + +func (s *Unnest_expression_with_opt_alias_and_offsetContext) Opt_with_offset_and_alias() IOpt_with_offset_and_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_with_offset_and_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_with_offset_and_aliasContext) +} + +func (s *Unnest_expression_with_opt_alias_and_offsetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unnest_expression_with_opt_alias_and_offsetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unnest_expression_with_opt_alias_and_offsetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterUnnest_expression_with_opt_alias_and_offset(s) + } +} + +func (s *Unnest_expression_with_opt_alias_and_offsetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitUnnest_expression_with_opt_alias_and_offset(s) + } +} + +func (s *Unnest_expression_with_opt_alias_and_offsetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitUnnest_expression_with_opt_alias_and_offset(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Unnest_expression_with_opt_alias_and_offset() (localctx IUnnest_expression_with_opt_alias_and_offsetContext) { + localctx = NewUnnest_expression_with_opt_alias_and_offsetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 304, GoogleSQLParserRULE_unnest_expression_with_opt_alias_and_offset) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2741) + p.Unnest_expression() + } + p.SetState(2743) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-58)) & ^0x3f) == 0 && ((int64(1)<<(_la-58))&-6981105432269881343) != 0) || ((int64((_la-122)) & ^0x3f) == 0 && ((int64(1)<<(_la-122))&-1) != 0) || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&-1) != 0) || ((int64((_la-250)) & ^0x3f) == 0 && ((int64(1)<<(_la-250))&35184372088703) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&33488865) != 0) { + { + p.SetState(2742) + p.As_alias() + } + + } + p.SetState(2746) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWITH_SYMBOL { + { + p.SetState(2745) + p.Opt_with_offset_and_alias() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOn_path_expressionContext is an interface to support dynamic dispatch. +type IOn_path_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + + // IsOn_path_expressionContext differentiates from other interfaces. + IsOn_path_expressionContext() +} + +type On_path_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOn_path_expressionContext() *On_path_expressionContext { + var p = new(On_path_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_on_path_expression + return p +} + +func InitEmptyOn_path_expressionContext(p *On_path_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_on_path_expression +} + +func (*On_path_expressionContext) IsOn_path_expressionContext() {} + +func NewOn_path_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_path_expressionContext { + var p = new(On_path_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_on_path_expression + + return p +} + +func (s *On_path_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_path_expressionContext) ON_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserON_SYMBOL, 0) +} + +func (s *On_path_expressionContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *On_path_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_path_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_path_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOn_path_expression(s) + } +} + +func (s *On_path_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOn_path_expression(s) + } +} + +func (s *On_path_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOn_path_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) On_path_expression() (localctx IOn_path_expressionContext) { + localctx = NewOn_path_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 306, GoogleSQLParserRULE_on_path_expression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2748) + p.Match(GoogleSQLParserON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2749) + p.Path_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_typeContext is an interface to support dynamic dispatch. +type IIndex_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SEARCH_SYMBOL() antlr.TerminalNode + VECTOR_SYMBOL() antlr.TerminalNode + + // IsIndex_typeContext differentiates from other interfaces. + IsIndex_typeContext() +} + +type Index_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_typeContext() *Index_typeContext { + var p = new(Index_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_index_type + return p +} + +func InitEmptyIndex_typeContext(p *Index_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_index_type +} + +func (*Index_typeContext) IsIndex_typeContext() {} + +func NewIndex_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_typeContext { + var p = new(Index_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_index_type + + return p +} + +func (s *Index_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_typeContext) SEARCH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSEARCH_SYMBOL, 0) +} + +func (s *Index_typeContext) VECTOR_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserVECTOR_SYMBOL, 0) +} + +func (s *Index_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterIndex_type(s) + } +} + +func (s *Index_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitIndex_type(s) + } +} + +func (s *Index_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitIndex_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Index_type() (localctx IIndex_typeContext) { + localctx = NewIndex_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 308, GoogleSQLParserRULE_index_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2751) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserSEARCH_SYMBOL || _la == GoogleSQLParserVECTOR_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_spanner_null_filteredContext is an interface to support dynamic dispatch. +type IOpt_spanner_null_filteredContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NULL_FILTERED_SYMBOL() antlr.TerminalNode + + // IsOpt_spanner_null_filteredContext differentiates from other interfaces. + IsOpt_spanner_null_filteredContext() +} + +type Opt_spanner_null_filteredContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_spanner_null_filteredContext() *Opt_spanner_null_filteredContext { + var p = new(Opt_spanner_null_filteredContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_spanner_null_filtered + return p +} + +func InitEmptyOpt_spanner_null_filteredContext(p *Opt_spanner_null_filteredContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_spanner_null_filtered +} + +func (*Opt_spanner_null_filteredContext) IsOpt_spanner_null_filteredContext() {} + +func NewOpt_spanner_null_filteredContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_spanner_null_filteredContext { + var p = new(Opt_spanner_null_filteredContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_spanner_null_filtered + + return p +} + +func (s *Opt_spanner_null_filteredContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_spanner_null_filteredContext) NULL_FILTERED_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNULL_FILTERED_SYMBOL, 0) +} + +func (s *Opt_spanner_null_filteredContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_spanner_null_filteredContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_spanner_null_filteredContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_spanner_null_filtered(s) + } +} + +func (s *Opt_spanner_null_filteredContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_spanner_null_filtered(s) + } +} + +func (s *Opt_spanner_null_filteredContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_spanner_null_filtered(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_spanner_null_filtered() (localctx IOpt_spanner_null_filteredContext) { + localctx = NewOpt_spanner_null_filteredContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 310, GoogleSQLParserRULE_opt_spanner_null_filtered) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2753) + p.Match(GoogleSQLParserNULL_FILTERED_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_procedure_statementContext is an interface to support dynamic dispatch. +type ICreate_procedure_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE_SYMBOL() antlr.TerminalNode + PROCEDURE_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + Procedure_parameters() IProcedure_parametersContext + Begin_end_block_or_language_as_code() IBegin_end_block_or_language_as_codeContext + Opt_or_replace() IOpt_or_replaceContext + Opt_create_scope() IOpt_create_scopeContext + Opt_if_not_exists() IOpt_if_not_existsContext + Opt_external_security_clause() IOpt_external_security_clauseContext + With_connection_clause() IWith_connection_clauseContext + Opt_options_list() IOpt_options_listContext + + // IsCreate_procedure_statementContext differentiates from other interfaces. + IsCreate_procedure_statementContext() +} + +type Create_procedure_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_procedure_statementContext() *Create_procedure_statementContext { + var p = new(Create_procedure_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_procedure_statement + return p +} + +func InitEmptyCreate_procedure_statementContext(p *Create_procedure_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_procedure_statement +} + +func (*Create_procedure_statementContext) IsCreate_procedure_statementContext() {} + +func NewCreate_procedure_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_procedure_statementContext { + var p = new(Create_procedure_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_create_procedure_statement + + return p +} + +func (s *Create_procedure_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_procedure_statementContext) CREATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCREATE_SYMBOL, 0) +} + +func (s *Create_procedure_statementContext) PROCEDURE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPROCEDURE_SYMBOL, 0) +} + +func (s *Create_procedure_statementContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Create_procedure_statementContext) Procedure_parameters() IProcedure_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_parametersContext) +} + +func (s *Create_procedure_statementContext) Begin_end_block_or_language_as_code() IBegin_end_block_or_language_as_codeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBegin_end_block_or_language_as_codeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBegin_end_block_or_language_as_codeContext) +} + +func (s *Create_procedure_statementContext) Opt_or_replace() IOpt_or_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_replaceContext) +} + +func (s *Create_procedure_statementContext) Opt_create_scope() IOpt_create_scopeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_create_scopeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_create_scopeContext) +} + +func (s *Create_procedure_statementContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *Create_procedure_statementContext) Opt_external_security_clause() IOpt_external_security_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_external_security_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_external_security_clauseContext) +} + +func (s *Create_procedure_statementContext) With_connection_clause() IWith_connection_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_connection_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_connection_clauseContext) +} + +func (s *Create_procedure_statementContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Create_procedure_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_procedure_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_procedure_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCreate_procedure_statement(s) + } +} + +func (s *Create_procedure_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCreate_procedure_statement(s) + } +} + +func (s *Create_procedure_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCreate_procedure_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Create_procedure_statement() (localctx ICreate_procedure_statementContext) { + localctx = NewCreate_procedure_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 312, GoogleSQLParserRULE_create_procedure_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2755) + p.Match(GoogleSQLParserCREATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2757) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOR_SYMBOL { + { + p.SetState(2756) + p.Opt_or_replace() + } + + } + p.SetState(2760) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-226)) & ^0x3f) == 0 && ((int64(1)<<(_la-226))&105553116266529) != 0 { + { + p.SetState(2759) + p.Opt_create_scope() + } + + } + { + p.SetState(2762) + p.Match(GoogleSQLParserPROCEDURE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2764) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(2763) + p.Opt_if_not_exists() + } + + } + { + p.SetState(2766) + p.Path_expression() + } + { + p.SetState(2767) + p.Procedure_parameters() + } + p.SetState(2769) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserEXTERNAL_SYMBOL { + { + p.SetState(2768) + p.Opt_external_security_clause() + } + + } + p.SetState(2772) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWITH_SYMBOL { + { + p.SetState(2771) + p.With_connection_clause() + } + + } + p.SetState(2775) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(2774) + p.Opt_options_list() + } + + } + { + p.SetState(2777) + p.Begin_end_block_or_language_as_code() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBegin_end_block_or_language_as_codeContext is an interface to support dynamic dispatch. +type IBegin_end_block_or_language_as_codeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Begin_end_block() IBegin_end_blockContext + LANGUAGE_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + Opt_as_code() IOpt_as_codeContext + + // IsBegin_end_block_or_language_as_codeContext differentiates from other interfaces. + IsBegin_end_block_or_language_as_codeContext() +} + +type Begin_end_block_or_language_as_codeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBegin_end_block_or_language_as_codeContext() *Begin_end_block_or_language_as_codeContext { + var p = new(Begin_end_block_or_language_as_codeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_begin_end_block_or_language_as_code + return p +} + +func InitEmptyBegin_end_block_or_language_as_codeContext(p *Begin_end_block_or_language_as_codeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_begin_end_block_or_language_as_code +} + +func (*Begin_end_block_or_language_as_codeContext) IsBegin_end_block_or_language_as_codeContext() {} + +func NewBegin_end_block_or_language_as_codeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Begin_end_block_or_language_as_codeContext { + var p = new(Begin_end_block_or_language_as_codeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_begin_end_block_or_language_as_code + + return p +} + +func (s *Begin_end_block_or_language_as_codeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Begin_end_block_or_language_as_codeContext) Begin_end_block() IBegin_end_blockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBegin_end_blockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBegin_end_blockContext) +} + +func (s *Begin_end_block_or_language_as_codeContext) LANGUAGE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLANGUAGE_SYMBOL, 0) +} + +func (s *Begin_end_block_or_language_as_codeContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Begin_end_block_or_language_as_codeContext) Opt_as_code() IOpt_as_codeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_as_codeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_as_codeContext) +} + +func (s *Begin_end_block_or_language_as_codeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Begin_end_block_or_language_as_codeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Begin_end_block_or_language_as_codeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterBegin_end_block_or_language_as_code(s) + } +} + +func (s *Begin_end_block_or_language_as_codeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitBegin_end_block_or_language_as_code(s) + } +} + +func (s *Begin_end_block_or_language_as_codeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitBegin_end_block_or_language_as_code(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Begin_end_block_or_language_as_code() (localctx IBegin_end_block_or_language_as_codeContext) { + localctx = NewBegin_end_block_or_language_as_codeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 314, GoogleSQLParserRULE_begin_end_block_or_language_as_code) + var _la int + + p.SetState(2785) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserBEGIN_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2779) + p.Begin_end_block() + } + + case GoogleSQLParserLANGUAGE_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2780) + p.Match(GoogleSQLParserLANGUAGE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2781) + p.Identifier() + } + p.SetState(2783) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(2782) + p.Opt_as_code() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBegin_end_blockContext is an interface to support dynamic dispatch. +type IBegin_end_blockContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BEGIN_SYMBOL() antlr.TerminalNode + END_SYMBOL() antlr.TerminalNode + Statement_list() IStatement_listContext + Opt_exception_handler() IOpt_exception_handlerContext + + // IsBegin_end_blockContext differentiates from other interfaces. + IsBegin_end_blockContext() +} + +type Begin_end_blockContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBegin_end_blockContext() *Begin_end_blockContext { + var p = new(Begin_end_blockContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_begin_end_block + return p +} + +func InitEmptyBegin_end_blockContext(p *Begin_end_blockContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_begin_end_block +} + +func (*Begin_end_blockContext) IsBegin_end_blockContext() {} + +func NewBegin_end_blockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Begin_end_blockContext { + var p = new(Begin_end_blockContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_begin_end_block + + return p +} + +func (s *Begin_end_blockContext) GetParser() antlr.Parser { return s.parser } + +func (s *Begin_end_blockContext) BEGIN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBEGIN_SYMBOL, 0) +} + +func (s *Begin_end_blockContext) END_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEND_SYMBOL, 0) +} + +func (s *Begin_end_blockContext) Statement_list() IStatement_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatement_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatement_listContext) +} + +func (s *Begin_end_blockContext) Opt_exception_handler() IOpt_exception_handlerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_exception_handlerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_exception_handlerContext) +} + +func (s *Begin_end_blockContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Begin_end_blockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Begin_end_blockContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterBegin_end_block(s) + } +} + +func (s *Begin_end_blockContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitBegin_end_block(s) + } +} + +func (s *Begin_end_blockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitBegin_end_block(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Begin_end_block() (localctx IBegin_end_blockContext) { + localctx = NewBegin_end_blockContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 316, GoogleSQLParserRULE_begin_end_block) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2787) + p.Match(GoogleSQLParserBEGIN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2789) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 276, p.GetParserRuleContext()) == 1 { + { + p.SetState(2788) + p.Statement_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2792) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserEXCEPTION_SYMBOL { + { + p.SetState(2791) + p.Opt_exception_handler() + } + + } + { + p.SetState(2794) + p.Match(GoogleSQLParserEND_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_exception_handlerContext is an interface to support dynamic dispatch. +type IOpt_exception_handlerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXCEPTION_SYMBOL() antlr.TerminalNode + WHEN_SYMBOL() antlr.TerminalNode + ERROR_SYMBOL() antlr.TerminalNode + THEN_SYMBOL() antlr.TerminalNode + Statement_list() IStatement_listContext + + // IsOpt_exception_handlerContext differentiates from other interfaces. + IsOpt_exception_handlerContext() +} + +type Opt_exception_handlerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_exception_handlerContext() *Opt_exception_handlerContext { + var p = new(Opt_exception_handlerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_exception_handler + return p +} + +func InitEmptyOpt_exception_handlerContext(p *Opt_exception_handlerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_exception_handler +} + +func (*Opt_exception_handlerContext) IsOpt_exception_handlerContext() {} + +func NewOpt_exception_handlerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_exception_handlerContext { + var p = new(Opt_exception_handlerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_exception_handler + + return p +} + +func (s *Opt_exception_handlerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_exception_handlerContext) EXCEPTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXCEPTION_SYMBOL, 0) +} + +func (s *Opt_exception_handlerContext) WHEN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWHEN_SYMBOL, 0) +} + +func (s *Opt_exception_handlerContext) ERROR_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserERROR_SYMBOL, 0) +} + +func (s *Opt_exception_handlerContext) THEN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTHEN_SYMBOL, 0) +} + +func (s *Opt_exception_handlerContext) Statement_list() IStatement_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatement_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatement_listContext) +} + +func (s *Opt_exception_handlerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_exception_handlerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_exception_handlerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_exception_handler(s) + } +} + +func (s *Opt_exception_handlerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_exception_handler(s) + } +} + +func (s *Opt_exception_handlerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_exception_handler(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_exception_handler() (localctx IOpt_exception_handlerContext) { + localctx = NewOpt_exception_handlerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 318, GoogleSQLParserRULE_opt_exception_handler) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2796) + p.Match(GoogleSQLParserEXCEPTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2797) + p.Match(GoogleSQLParserWHEN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2798) + p.Match(GoogleSQLParserERROR_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2799) + p.Match(GoogleSQLParserTHEN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2800) + p.Statement_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStatement_listContext is an interface to support dynamic dispatch. +type IStatement_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Unterminated_non_empty_statement_list() IUnterminated_non_empty_statement_listContext + SEMI_SYMBOL() antlr.TerminalNode + + // IsStatement_listContext differentiates from other interfaces. + IsStatement_listContext() +} + +type Statement_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStatement_listContext() *Statement_listContext { + var p = new(Statement_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_statement_list + return p +} + +func InitEmptyStatement_listContext(p *Statement_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_statement_list +} + +func (*Statement_listContext) IsStatement_listContext() {} + +func NewStatement_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Statement_listContext { + var p = new(Statement_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_statement_list + + return p +} + +func (s *Statement_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Statement_listContext) Unterminated_non_empty_statement_list() IUnterminated_non_empty_statement_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnterminated_non_empty_statement_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnterminated_non_empty_statement_listContext) +} + +func (s *Statement_listContext) SEMI_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSEMI_SYMBOL, 0) +} + +func (s *Statement_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Statement_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Statement_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterStatement_list(s) + } +} + +func (s *Statement_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitStatement_list(s) + } +} + +func (s *Statement_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitStatement_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Statement_list() (localctx IStatement_listContext) { + localctx = NewStatement_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 320, GoogleSQLParserRULE_statement_list) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2802) + p.Unterminated_non_empty_statement_list() + } + { + p.SetState(2803) + p.Match(GoogleSQLParserSEMI_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnterminated_non_empty_statement_listContext is an interface to support dynamic dispatch. +type IUnterminated_non_empty_statement_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllUnterminated_statement() []IUnterminated_statementContext + Unterminated_statement(i int) IUnterminated_statementContext + AllSEMI_SYMBOL() []antlr.TerminalNode + SEMI_SYMBOL(i int) antlr.TerminalNode + + // IsUnterminated_non_empty_statement_listContext differentiates from other interfaces. + IsUnterminated_non_empty_statement_listContext() +} + +type Unterminated_non_empty_statement_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnterminated_non_empty_statement_listContext() *Unterminated_non_empty_statement_listContext { + var p = new(Unterminated_non_empty_statement_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unterminated_non_empty_statement_list + return p +} + +func InitEmptyUnterminated_non_empty_statement_listContext(p *Unterminated_non_empty_statement_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unterminated_non_empty_statement_list +} + +func (*Unterminated_non_empty_statement_listContext) IsUnterminated_non_empty_statement_listContext() { +} + +func NewUnterminated_non_empty_statement_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unterminated_non_empty_statement_listContext { + var p = new(Unterminated_non_empty_statement_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_unterminated_non_empty_statement_list + + return p +} + +func (s *Unterminated_non_empty_statement_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unterminated_non_empty_statement_listContext) AllUnterminated_statement() []IUnterminated_statementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUnterminated_statementContext); ok { + len++ + } + } + + tst := make([]IUnterminated_statementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUnterminated_statementContext); ok { + tst[i] = t.(IUnterminated_statementContext) + i++ + } + } + + return tst +} + +func (s *Unterminated_non_empty_statement_listContext) Unterminated_statement(i int) IUnterminated_statementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnterminated_statementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUnterminated_statementContext) +} + +func (s *Unterminated_non_empty_statement_listContext) AllSEMI_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserSEMI_SYMBOL) +} + +func (s *Unterminated_non_empty_statement_listContext) SEMI_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSEMI_SYMBOL, i) +} + +func (s *Unterminated_non_empty_statement_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unterminated_non_empty_statement_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unterminated_non_empty_statement_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterUnterminated_non_empty_statement_list(s) + } +} + +func (s *Unterminated_non_empty_statement_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitUnterminated_non_empty_statement_list(s) + } +} + +func (s *Unterminated_non_empty_statement_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitUnterminated_non_empty_statement_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Unterminated_non_empty_statement_list() (localctx IUnterminated_non_empty_statement_listContext) { + localctx = NewUnterminated_non_empty_statement_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 322, GoogleSQLParserRULE_unterminated_non_empty_statement_list) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2805) + p.Unterminated_statement() + } + p.SetState(2810) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 278, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2806) + p.Match(GoogleSQLParserSEMI_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2807) + p.Unterminated_statement() + } + + } + p.SetState(2812) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 278, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnterminated_statementContext is an interface to support dynamic dispatch. +type IUnterminated_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Unterminated_sql_statement() IUnterminated_sql_statementContext + Unterminated_script_statement() IUnterminated_script_statementContext + + // IsUnterminated_statementContext differentiates from other interfaces. + IsUnterminated_statementContext() +} + +type Unterminated_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnterminated_statementContext() *Unterminated_statementContext { + var p = new(Unterminated_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unterminated_statement + return p +} + +func InitEmptyUnterminated_statementContext(p *Unterminated_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unterminated_statement +} + +func (*Unterminated_statementContext) IsUnterminated_statementContext() {} + +func NewUnterminated_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unterminated_statementContext { + var p = new(Unterminated_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_unterminated_statement + + return p +} + +func (s *Unterminated_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unterminated_statementContext) Unterminated_sql_statement() IUnterminated_sql_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnterminated_sql_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnterminated_sql_statementContext) +} + +func (s *Unterminated_statementContext) Unterminated_script_statement() IUnterminated_script_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnterminated_script_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnterminated_script_statementContext) +} + +func (s *Unterminated_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unterminated_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unterminated_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterUnterminated_statement(s) + } +} + +func (s *Unterminated_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitUnterminated_statement(s) + } +} + +func (s *Unterminated_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitUnterminated_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Unterminated_statement() (localctx IUnterminated_statementContext) { + localctx = NewUnterminated_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 324, GoogleSQLParserRULE_unterminated_statement) + p.SetState(2815) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 279, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2813) + p.Unterminated_sql_statement() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2814) + p.Unterminated_script_statement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnterminated_script_statementContext is an interface to support dynamic dispatch. +type IUnterminated_script_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + If_statement() IIf_statementContext + Case_statement() ICase_statementContext + Variable_declaration() IVariable_declarationContext + Break_statement() IBreak_statementContext + Continue_statement() IContinue_statementContext + Return_statement() IReturn_statementContext + Raise_statement() IRaise_statementContext + Unterminated_unlabeled_script_statement() IUnterminated_unlabeled_script_statementContext + Label() ILabelContext + COLON_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsUnterminated_script_statementContext differentiates from other interfaces. + IsUnterminated_script_statementContext() +} + +type Unterminated_script_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnterminated_script_statementContext() *Unterminated_script_statementContext { + var p = new(Unterminated_script_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unterminated_script_statement + return p +} + +func InitEmptyUnterminated_script_statementContext(p *Unterminated_script_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unterminated_script_statement +} + +func (*Unterminated_script_statementContext) IsUnterminated_script_statementContext() {} + +func NewUnterminated_script_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unterminated_script_statementContext { + var p = new(Unterminated_script_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_unterminated_script_statement + + return p +} + +func (s *Unterminated_script_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unterminated_script_statementContext) If_statement() IIf_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_statementContext) +} + +func (s *Unterminated_script_statementContext) Case_statement() ICase_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICase_statementContext) +} + +func (s *Unterminated_script_statementContext) Variable_declaration() IVariable_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariable_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariable_declarationContext) +} + +func (s *Unterminated_script_statementContext) Break_statement() IBreak_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBreak_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBreak_statementContext) +} + +func (s *Unterminated_script_statementContext) Continue_statement() IContinue_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContinue_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContinue_statementContext) +} + +func (s *Unterminated_script_statementContext) Return_statement() IReturn_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReturn_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReturn_statementContext) +} + +func (s *Unterminated_script_statementContext) Raise_statement() IRaise_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRaise_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRaise_statementContext) +} + +func (s *Unterminated_script_statementContext) Unterminated_unlabeled_script_statement() IUnterminated_unlabeled_script_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnterminated_unlabeled_script_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnterminated_unlabeled_script_statementContext) +} + +func (s *Unterminated_script_statementContext) Label() ILabelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabelContext) +} + +func (s *Unterminated_script_statementContext) COLON_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOLON_SYMBOL, 0) +} + +func (s *Unterminated_script_statementContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Unterminated_script_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unterminated_script_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unterminated_script_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterUnterminated_script_statement(s) + } +} + +func (s *Unterminated_script_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitUnterminated_script_statement(s) + } +} + +func (s *Unterminated_script_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitUnterminated_script_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Unterminated_script_statement() (localctx IUnterminated_script_statementContext) { + localctx = NewUnterminated_script_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 326, GoogleSQLParserRULE_unterminated_script_statement) + var _la int + + p.SetState(2831) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 281, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2817) + p.If_statement() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2818) + p.Case_statement() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2819) + p.Variable_declaration() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2820) + p.Break_statement() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2821) + p.Continue_statement() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2822) + p.Return_statement() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2823) + p.Raise_statement() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2824) + p.Unterminated_unlabeled_script_statement() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(2825) + p.Label() + } + { + p.SetState(2826) + p.Match(GoogleSQLParserCOLON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2827) + p.Unterminated_unlabeled_script_statement() + } + p.SetState(2829) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-74)) & ^0x3f) == 0 && ((int64(1)<<(_la-74))&-106523215214079) != 0) || ((int64((_la-138)) & ^0x3f) == 0 && ((int64(1)<<(_la-138))&-1) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-36028797018963969) != 0) || ((int64((_la-266)) & ^0x3f) == 0 && ((int64(1)<<(_la-266))&536870911) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&33488865) != 0) { + { + p.SetState(2828) + p.Identifier() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILabelContext is an interface to support dynamic dispatch. +type ILabelContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsLabelContext differentiates from other interfaces. + IsLabelContext() +} + +type LabelContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLabelContext() *LabelContext { + var p = new(LabelContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_label + return p +} + +func InitEmptyLabelContext(p *LabelContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_label +} + +func (*LabelContext) IsLabelContext() {} + +func NewLabelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LabelContext { + var p = new(LabelContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_label + + return p +} + +func (s *LabelContext) GetParser() antlr.Parser { return s.parser } + +func (s *LabelContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *LabelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LabelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LabelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterLabel(s) + } +} + +func (s *LabelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitLabel(s) + } +} + +func (s *LabelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitLabel(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Label() (localctx ILabelContext) { + localctx = NewLabelContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 328, GoogleSQLParserRULE_label) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2833) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnterminated_unlabeled_script_statementContext is an interface to support dynamic dispatch. +type IUnterminated_unlabeled_script_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Begin_end_block() IBegin_end_blockContext + While_statement() IWhile_statementContext + Loop_statement() ILoop_statementContext + Repeat_statement() IRepeat_statementContext + For_in_statement() IFor_in_statementContext + + // IsUnterminated_unlabeled_script_statementContext differentiates from other interfaces. + IsUnterminated_unlabeled_script_statementContext() +} + +type Unterminated_unlabeled_script_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnterminated_unlabeled_script_statementContext() *Unterminated_unlabeled_script_statementContext { + var p = new(Unterminated_unlabeled_script_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unterminated_unlabeled_script_statement + return p +} + +func InitEmptyUnterminated_unlabeled_script_statementContext(p *Unterminated_unlabeled_script_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unterminated_unlabeled_script_statement +} + +func (*Unterminated_unlabeled_script_statementContext) IsUnterminated_unlabeled_script_statementContext() { +} + +func NewUnterminated_unlabeled_script_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unterminated_unlabeled_script_statementContext { + var p = new(Unterminated_unlabeled_script_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_unterminated_unlabeled_script_statement + + return p +} + +func (s *Unterminated_unlabeled_script_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unterminated_unlabeled_script_statementContext) Begin_end_block() IBegin_end_blockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBegin_end_blockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBegin_end_blockContext) +} + +func (s *Unterminated_unlabeled_script_statementContext) While_statement() IWhile_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhile_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhile_statementContext) +} + +func (s *Unterminated_unlabeled_script_statementContext) Loop_statement() ILoop_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILoop_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILoop_statementContext) +} + +func (s *Unterminated_unlabeled_script_statementContext) Repeat_statement() IRepeat_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRepeat_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRepeat_statementContext) +} + +func (s *Unterminated_unlabeled_script_statementContext) For_in_statement() IFor_in_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_in_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFor_in_statementContext) +} + +func (s *Unterminated_unlabeled_script_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unterminated_unlabeled_script_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unterminated_unlabeled_script_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterUnterminated_unlabeled_script_statement(s) + } +} + +func (s *Unterminated_unlabeled_script_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitUnterminated_unlabeled_script_statement(s) + } +} + +func (s *Unterminated_unlabeled_script_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitUnterminated_unlabeled_script_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Unterminated_unlabeled_script_statement() (localctx IUnterminated_unlabeled_script_statementContext) { + localctx = NewUnterminated_unlabeled_script_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 330, GoogleSQLParserRULE_unterminated_unlabeled_script_statement) + p.SetState(2840) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserBEGIN_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2835) + p.Begin_end_block() + } + + case GoogleSQLParserWHILE_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2836) + p.While_statement() + } + + case GoogleSQLParserLOOP_SYMBOL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2837) + p.Loop_statement() + } + + case GoogleSQLParserREPEAT_SYMBOL: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2838) + p.Repeat_statement() + } + + case GoogleSQLParserFOR_SYMBOL: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2839) + p.For_in_statement() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFor_in_statementContext is an interface to support dynamic dispatch. +type IFor_in_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllFOR_SYMBOL() []antlr.TerminalNode + FOR_SYMBOL(i int) antlr.TerminalNode + Identifier() IIdentifierContext + IN_SYMBOL() antlr.TerminalNode + Parenthesized_query() IParenthesized_queryContext + DO_SYMBOL() antlr.TerminalNode + END_SYMBOL() antlr.TerminalNode + Statement_list() IStatement_listContext + + // IsFor_in_statementContext differentiates from other interfaces. + IsFor_in_statementContext() +} + +type For_in_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFor_in_statementContext() *For_in_statementContext { + var p = new(For_in_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_for_in_statement + return p +} + +func InitEmptyFor_in_statementContext(p *For_in_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_for_in_statement +} + +func (*For_in_statementContext) IsFor_in_statementContext() {} + +func NewFor_in_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_in_statementContext { + var p = new(For_in_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_for_in_statement + + return p +} + +func (s *For_in_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *For_in_statementContext) AllFOR_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserFOR_SYMBOL) +} + +func (s *For_in_statementContext) FOR_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFOR_SYMBOL, i) +} + +func (s *For_in_statementContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *For_in_statementContext) IN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIN_SYMBOL, 0) +} + +func (s *For_in_statementContext) Parenthesized_query() IParenthesized_queryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesized_queryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParenthesized_queryContext) +} + +func (s *For_in_statementContext) DO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDO_SYMBOL, 0) +} + +func (s *For_in_statementContext) END_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEND_SYMBOL, 0) +} + +func (s *For_in_statementContext) Statement_list() IStatement_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatement_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatement_listContext) +} + +func (s *For_in_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *For_in_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *For_in_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterFor_in_statement(s) + } +} + +func (s *For_in_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitFor_in_statement(s) + } +} + +func (s *For_in_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitFor_in_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) For_in_statement() (localctx IFor_in_statementContext) { + localctx = NewFor_in_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 332, GoogleSQLParserRULE_for_in_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2842) + p.Match(GoogleSQLParserFOR_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2843) + p.Identifier() + } + { + p.SetState(2844) + p.Match(GoogleSQLParserIN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2845) + p.Parenthesized_query() + } + { + p.SetState(2846) + p.Match(GoogleSQLParserDO_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2848) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL || _la == GoogleSQLParserAT_SYMBOL || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-109078670720105279) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-1) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&284223755780095) != 0) || ((int64((_la-327)) & ^0x3f) == 0 && ((int64(1)<<(_la-327))&274340880385) != 0) { + { + p.SetState(2847) + p.Statement_list() + } + + } + { + p.SetState(2850) + p.Match(GoogleSQLParserEND_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2851) + p.Match(GoogleSQLParserFOR_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRepeat_statementContext is an interface to support dynamic dispatch. +type IRepeat_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllREPEAT_SYMBOL() []antlr.TerminalNode + REPEAT_SYMBOL(i int) antlr.TerminalNode + Until_clause() IUntil_clauseContext + END_SYMBOL() antlr.TerminalNode + Statement_list() IStatement_listContext + + // IsRepeat_statementContext differentiates from other interfaces. + IsRepeat_statementContext() +} + +type Repeat_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRepeat_statementContext() *Repeat_statementContext { + var p = new(Repeat_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_repeat_statement + return p +} + +func InitEmptyRepeat_statementContext(p *Repeat_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_repeat_statement +} + +func (*Repeat_statementContext) IsRepeat_statementContext() {} + +func NewRepeat_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Repeat_statementContext { + var p = new(Repeat_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_repeat_statement + + return p +} + +func (s *Repeat_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Repeat_statementContext) AllREPEAT_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserREPEAT_SYMBOL) +} + +func (s *Repeat_statementContext) REPEAT_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREPEAT_SYMBOL, i) +} + +func (s *Repeat_statementContext) Until_clause() IUntil_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUntil_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUntil_clauseContext) +} + +func (s *Repeat_statementContext) END_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEND_SYMBOL, 0) +} + +func (s *Repeat_statementContext) Statement_list() IStatement_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatement_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatement_listContext) +} + +func (s *Repeat_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Repeat_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Repeat_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterRepeat_statement(s) + } +} + +func (s *Repeat_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitRepeat_statement(s) + } +} + +func (s *Repeat_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitRepeat_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Repeat_statement() (localctx IRepeat_statementContext) { + localctx = NewRepeat_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 334, GoogleSQLParserRULE_repeat_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2853) + p.Match(GoogleSQLParserREPEAT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2855) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 284, p.GetParserRuleContext()) == 1 { + { + p.SetState(2854) + p.Statement_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2857) + p.Until_clause() + } + { + p.SetState(2858) + p.Match(GoogleSQLParserEND_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2859) + p.Match(GoogleSQLParserREPEAT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUntil_clauseContext is an interface to support dynamic dispatch. +type IUntil_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNTIL_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + + // IsUntil_clauseContext differentiates from other interfaces. + IsUntil_clauseContext() +} + +type Until_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUntil_clauseContext() *Until_clauseContext { + var p = new(Until_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_until_clause + return p +} + +func InitEmptyUntil_clauseContext(p *Until_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_until_clause +} + +func (*Until_clauseContext) IsUntil_clauseContext() {} + +func NewUntil_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Until_clauseContext { + var p = new(Until_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_until_clause + + return p +} + +func (s *Until_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Until_clauseContext) UNTIL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUNTIL_SYMBOL, 0) +} + +func (s *Until_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Until_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Until_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Until_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterUntil_clause(s) + } +} + +func (s *Until_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitUntil_clause(s) + } +} + +func (s *Until_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitUntil_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Until_clause() (localctx IUntil_clauseContext) { + localctx = NewUntil_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 336, GoogleSQLParserRULE_until_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2861) + p.Match(GoogleSQLParserUNTIL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2862) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILoop_statementContext is an interface to support dynamic dispatch. +type ILoop_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllLOOP_SYMBOL() []antlr.TerminalNode + LOOP_SYMBOL(i int) antlr.TerminalNode + END_SYMBOL() antlr.TerminalNode + Statement_list() IStatement_listContext + + // IsLoop_statementContext differentiates from other interfaces. + IsLoop_statementContext() +} + +type Loop_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLoop_statementContext() *Loop_statementContext { + var p = new(Loop_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_loop_statement + return p +} + +func InitEmptyLoop_statementContext(p *Loop_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_loop_statement +} + +func (*Loop_statementContext) IsLoop_statementContext() {} + +func NewLoop_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Loop_statementContext { + var p = new(Loop_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_loop_statement + + return p +} + +func (s *Loop_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Loop_statementContext) AllLOOP_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserLOOP_SYMBOL) +} + +func (s *Loop_statementContext) LOOP_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLOOP_SYMBOL, i) +} + +func (s *Loop_statementContext) END_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEND_SYMBOL, 0) +} + +func (s *Loop_statementContext) Statement_list() IStatement_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatement_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatement_listContext) +} + +func (s *Loop_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Loop_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Loop_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterLoop_statement(s) + } +} + +func (s *Loop_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitLoop_statement(s) + } +} + +func (s *Loop_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitLoop_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Loop_statement() (localctx ILoop_statementContext) { + localctx = NewLoop_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 338, GoogleSQLParserRULE_loop_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2864) + p.Match(GoogleSQLParserLOOP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2866) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL || _la == GoogleSQLParserAT_SYMBOL || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-109078670720105279) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-1) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&284223755780095) != 0) || ((int64((_la-327)) & ^0x3f) == 0 && ((int64(1)<<(_la-327))&274340880385) != 0) { + { + p.SetState(2865) + p.Statement_list() + } + + } + { + p.SetState(2868) + p.Match(GoogleSQLParserEND_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2869) + p.Match(GoogleSQLParserLOOP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWhile_statementContext is an interface to support dynamic dispatch. +type IWhile_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllWHILE_SYMBOL() []antlr.TerminalNode + WHILE_SYMBOL(i int) antlr.TerminalNode + Expression() IExpressionContext + DO_SYMBOL() antlr.TerminalNode + END_SYMBOL() antlr.TerminalNode + Statement_list() IStatement_listContext + + // IsWhile_statementContext differentiates from other interfaces. + IsWhile_statementContext() +} + +type While_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWhile_statementContext() *While_statementContext { + var p = new(While_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_while_statement + return p +} + +func InitEmptyWhile_statementContext(p *While_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_while_statement +} + +func (*While_statementContext) IsWhile_statementContext() {} + +func NewWhile_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *While_statementContext { + var p = new(While_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_while_statement + + return p +} + +func (s *While_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *While_statementContext) AllWHILE_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserWHILE_SYMBOL) +} + +func (s *While_statementContext) WHILE_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWHILE_SYMBOL, i) +} + +func (s *While_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *While_statementContext) DO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDO_SYMBOL, 0) +} + +func (s *While_statementContext) END_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEND_SYMBOL, 0) +} + +func (s *While_statementContext) Statement_list() IStatement_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatement_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatement_listContext) +} + +func (s *While_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *While_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *While_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterWhile_statement(s) + } +} + +func (s *While_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitWhile_statement(s) + } +} + +func (s *While_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitWhile_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) While_statement() (localctx IWhile_statementContext) { + localctx = NewWhile_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 340, GoogleSQLParserRULE_while_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2871) + p.Match(GoogleSQLParserWHILE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2872) + p.expression(0) + } + { + p.SetState(2873) + p.Match(GoogleSQLParserDO_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2875) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL || _la == GoogleSQLParserAT_SYMBOL || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-109078670720105279) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-1) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&284223755780095) != 0) || ((int64((_la-327)) & ^0x3f) == 0 && ((int64(1)<<(_la-327))&274340880385) != 0) { + { + p.SetState(2874) + p.Statement_list() + } + + } + { + p.SetState(2877) + p.Match(GoogleSQLParserEND_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2878) + p.Match(GoogleSQLParserWHILE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRaise_statementContext is an interface to support dynamic dispatch. +type IRaise_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RAISE_SYMBOL() antlr.TerminalNode + USING_SYMBOL() antlr.TerminalNode + MESSAGE_SYMBOL() antlr.TerminalNode + EQUAL_OPERATOR() antlr.TerminalNode + Expression() IExpressionContext + + // IsRaise_statementContext differentiates from other interfaces. + IsRaise_statementContext() +} + +type Raise_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRaise_statementContext() *Raise_statementContext { + var p = new(Raise_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_raise_statement + return p +} + +func InitEmptyRaise_statementContext(p *Raise_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_raise_statement +} + +func (*Raise_statementContext) IsRaise_statementContext() {} + +func NewRaise_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Raise_statementContext { + var p = new(Raise_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_raise_statement + + return p +} + +func (s *Raise_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Raise_statementContext) RAISE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRAISE_SYMBOL, 0) +} + +func (s *Raise_statementContext) USING_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUSING_SYMBOL, 0) +} + +func (s *Raise_statementContext) MESSAGE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMESSAGE_SYMBOL, 0) +} + +func (s *Raise_statementContext) EQUAL_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEQUAL_OPERATOR, 0) +} + +func (s *Raise_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Raise_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Raise_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Raise_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterRaise_statement(s) + } +} + +func (s *Raise_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitRaise_statement(s) + } +} + +func (s *Raise_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitRaise_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Raise_statement() (localctx IRaise_statementContext) { + localctx = NewRaise_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 342, GoogleSQLParserRULE_raise_statement) + p.SetState(2886) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 287, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2880) + p.Match(GoogleSQLParserRAISE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2881) + p.Match(GoogleSQLParserRAISE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2882) + p.Match(GoogleSQLParserUSING_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2883) + p.Match(GoogleSQLParserMESSAGE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2884) + p.Match(GoogleSQLParserEQUAL_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2885) + p.expression(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReturn_statementContext is an interface to support dynamic dispatch. +type IReturn_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETURN_SYMBOL() antlr.TerminalNode + + // IsReturn_statementContext differentiates from other interfaces. + IsReturn_statementContext() +} + +type Return_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReturn_statementContext() *Return_statementContext { + var p = new(Return_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_return_statement + return p +} + +func InitEmptyReturn_statementContext(p *Return_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_return_statement +} + +func (*Return_statementContext) IsReturn_statementContext() {} + +func NewReturn_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Return_statementContext { + var p = new(Return_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_return_statement + + return p +} + +func (s *Return_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Return_statementContext) RETURN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRETURN_SYMBOL, 0) +} + +func (s *Return_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Return_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Return_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterReturn_statement(s) + } +} + +func (s *Return_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitReturn_statement(s) + } +} + +func (s *Return_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitReturn_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Return_statement() (localctx IReturn_statementContext) { + localctx = NewReturn_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 344, GoogleSQLParserRULE_return_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2888) + p.Match(GoogleSQLParserRETURN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IContinue_statementContext is an interface to support dynamic dispatch. +type IContinue_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONTINUE_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + ITERATE_SYMBOL() antlr.TerminalNode + + // IsContinue_statementContext differentiates from other interfaces. + IsContinue_statementContext() +} + +type Continue_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyContinue_statementContext() *Continue_statementContext { + var p = new(Continue_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_continue_statement + return p +} + +func InitEmptyContinue_statementContext(p *Continue_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_continue_statement +} + +func (*Continue_statementContext) IsContinue_statementContext() {} + +func NewContinue_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Continue_statementContext { + var p = new(Continue_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_continue_statement + + return p +} + +func (s *Continue_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Continue_statementContext) CONTINUE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCONTINUE_SYMBOL, 0) +} + +func (s *Continue_statementContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Continue_statementContext) ITERATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserITERATE_SYMBOL, 0) +} + +func (s *Continue_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Continue_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Continue_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterContinue_statement(s) + } +} + +func (s *Continue_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitContinue_statement(s) + } +} + +func (s *Continue_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitContinue_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Continue_statement() (localctx IContinue_statementContext) { + localctx = NewContinue_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 346, GoogleSQLParserRULE_continue_statement) + var _la int + + p.SetState(2898) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserCONTINUE_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2890) + p.Match(GoogleSQLParserCONTINUE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2892) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-74)) & ^0x3f) == 0 && ((int64(1)<<(_la-74))&-106523215214079) != 0) || ((int64((_la-138)) & ^0x3f) == 0 && ((int64(1)<<(_la-138))&-1) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-36028797018963969) != 0) || ((int64((_la-266)) & ^0x3f) == 0 && ((int64(1)<<(_la-266))&536870911) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&33488865) != 0) { + { + p.SetState(2891) + p.Identifier() + } + + } + + case GoogleSQLParserITERATE_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2894) + p.Match(GoogleSQLParserITERATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2896) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-74)) & ^0x3f) == 0 && ((int64(1)<<(_la-74))&-106523215214079) != 0) || ((int64((_la-138)) & ^0x3f) == 0 && ((int64(1)<<(_la-138))&-1) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-36028797018963969) != 0) || ((int64((_la-266)) & ^0x3f) == 0 && ((int64(1)<<(_la-266))&536870911) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&33488865) != 0) { + { + p.SetState(2895) + p.Identifier() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVariable_declarationContext is an interface to support dynamic dispatch. +type IVariable_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DECLARE_SYMBOL() antlr.TerminalNode + Identifier_list() IIdentifier_listContext + Type_() ITypeContext + Opt_default_expression() IOpt_default_expressionContext + DEFAULT_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + + // IsVariable_declarationContext differentiates from other interfaces. + IsVariable_declarationContext() +} + +type Variable_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVariable_declarationContext() *Variable_declarationContext { + var p = new(Variable_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_variable_declaration + return p +} + +func InitEmptyVariable_declarationContext(p *Variable_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_variable_declaration +} + +func (*Variable_declarationContext) IsVariable_declarationContext() {} + +func NewVariable_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Variable_declarationContext { + var p = new(Variable_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_variable_declaration + + return p +} + +func (s *Variable_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Variable_declarationContext) DECLARE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDECLARE_SYMBOL, 0) +} + +func (s *Variable_declarationContext) Identifier_list() IIdentifier_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifier_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifier_listContext) +} + +func (s *Variable_declarationContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *Variable_declarationContext) Opt_default_expression() IOpt_default_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_default_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_default_expressionContext) +} + +func (s *Variable_declarationContext) DEFAULT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDEFAULT_SYMBOL, 0) +} + +func (s *Variable_declarationContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Variable_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Variable_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Variable_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterVariable_declaration(s) + } +} + +func (s *Variable_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitVariable_declaration(s) + } +} + +func (s *Variable_declarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitVariable_declaration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Variable_declaration() (localctx IVariable_declarationContext) { + localctx = NewVariable_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 348, GoogleSQLParserRULE_variable_declaration) + var _la int + + p.SetState(2911) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 292, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2900) + p.Match(GoogleSQLParserDECLARE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2901) + p.Identifier_list() + } + { + p.SetState(2902) + p.Type_() + } + p.SetState(2904) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserDEFAULT_SYMBOL { + { + p.SetState(2903) + p.Opt_default_expression() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2906) + p.Match(GoogleSQLParserDECLARE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2907) + p.Identifier_list() + } + { + p.SetState(2908) + p.Match(GoogleSQLParserDEFAULT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2909) + p.expression(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBreak_statementContext is an interface to support dynamic dispatch. +type IBreak_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BREAK_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + LEAVE_SYMBOL() antlr.TerminalNode + + // IsBreak_statementContext differentiates from other interfaces. + IsBreak_statementContext() +} + +type Break_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBreak_statementContext() *Break_statementContext { + var p = new(Break_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_break_statement + return p +} + +func InitEmptyBreak_statementContext(p *Break_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_break_statement +} + +func (*Break_statementContext) IsBreak_statementContext() {} + +func NewBreak_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Break_statementContext { + var p = new(Break_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_break_statement + + return p +} + +func (s *Break_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Break_statementContext) BREAK_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBREAK_SYMBOL, 0) +} + +func (s *Break_statementContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Break_statementContext) LEAVE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLEAVE_SYMBOL, 0) +} + +func (s *Break_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Break_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Break_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterBreak_statement(s) + } +} + +func (s *Break_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitBreak_statement(s) + } +} + +func (s *Break_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitBreak_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Break_statement() (localctx IBreak_statementContext) { + localctx = NewBreak_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 350, GoogleSQLParserRULE_break_statement) + var _la int + + p.SetState(2921) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserBREAK_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2913) + p.Match(GoogleSQLParserBREAK_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2915) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-74)) & ^0x3f) == 0 && ((int64(1)<<(_la-74))&-106523215214079) != 0) || ((int64((_la-138)) & ^0x3f) == 0 && ((int64(1)<<(_la-138))&-1) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-36028797018963969) != 0) || ((int64((_la-266)) & ^0x3f) == 0 && ((int64(1)<<(_la-266))&536870911) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&33488865) != 0) { + { + p.SetState(2914) + p.Identifier() + } + + } + + case GoogleSQLParserLEAVE_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2917) + p.Match(GoogleSQLParserLEAVE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2919) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-74)) & ^0x3f) == 0 && ((int64(1)<<(_la-74))&-106523215214079) != 0) || ((int64((_la-138)) & ^0x3f) == 0 && ((int64(1)<<(_la-138))&-1) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-36028797018963969) != 0) || ((int64((_la-266)) & ^0x3f) == 0 && ((int64(1)<<(_la-266))&536870911) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&33488865) != 0) { + { + p.SetState(2918) + p.Identifier() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICase_statementContext is an interface to support dynamic dispatch. +type ICase_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllCASE_SYMBOL() []antlr.TerminalNode + CASE_SYMBOL(i int) antlr.TerminalNode + When_then_clauses() IWhen_then_clausesContext + END_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + Opt_else() IOpt_elseContext + + // IsCase_statementContext differentiates from other interfaces. + IsCase_statementContext() +} + +type Case_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCase_statementContext() *Case_statementContext { + var p = new(Case_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_case_statement + return p +} + +func InitEmptyCase_statementContext(p *Case_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_case_statement +} + +func (*Case_statementContext) IsCase_statementContext() {} + +func NewCase_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_statementContext { + var p = new(Case_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_case_statement + + return p +} + +func (s *Case_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Case_statementContext) AllCASE_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCASE_SYMBOL) +} + +func (s *Case_statementContext) CASE_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCASE_SYMBOL, i) +} + +func (s *Case_statementContext) When_then_clauses() IWhen_then_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhen_then_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhen_then_clausesContext) +} + +func (s *Case_statementContext) END_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEND_SYMBOL, 0) +} + +func (s *Case_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Case_statementContext) Opt_else() IOpt_elseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_elseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_elseContext) +} + +func (s *Case_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Case_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Case_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCase_statement(s) + } +} + +func (s *Case_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCase_statement(s) + } +} + +func (s *Case_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCase_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Case_statement() (localctx ICase_statementContext) { + localctx = NewCase_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 352, GoogleSQLParserRULE_case_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2923) + p.Match(GoogleSQLParserCASE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2925) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&126153626265603072) != 0) || ((int64((_la-74)) & ^0x3f) == 0 && ((int64(1)<<(_la-74))&-825139475895) != 0) || ((int64((_la-138)) & ^0x3f) == 0 && ((int64(1)<<(_la-138))&-1) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-36028797018963969) != 0) || ((int64((_la-266)) & ^0x3f) == 0 && ((int64(1)<<(_la-266))&1068373114879) != 0) || ((int64((_la-332)) & ^0x3f) == 0 && ((int64(1)<<(_la-332))&8573149441) != 0) { + { + p.SetState(2924) + p.expression(0) + } + + } + { + p.SetState(2927) + p.When_then_clauses() + } + p.SetState(2929) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserELSE_SYMBOL { + { + p.SetState(2928) + p.Opt_else() + } + + } + { + p.SetState(2931) + p.Match(GoogleSQLParserEND_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2932) + p.Match(GoogleSQLParserCASE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWhen_then_clausesContext is an interface to support dynamic dispatch. +type IWhen_then_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllWHEN_SYMBOL() []antlr.TerminalNode + WHEN_SYMBOL(i int) antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllTHEN_SYMBOL() []antlr.TerminalNode + THEN_SYMBOL(i int) antlr.TerminalNode + AllStatement_list() []IStatement_listContext + Statement_list(i int) IStatement_listContext + + // IsWhen_then_clausesContext differentiates from other interfaces. + IsWhen_then_clausesContext() +} + +type When_then_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWhen_then_clausesContext() *When_then_clausesContext { + var p = new(When_then_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_when_then_clauses + return p +} + +func InitEmptyWhen_then_clausesContext(p *When_then_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_when_then_clauses +} + +func (*When_then_clausesContext) IsWhen_then_clausesContext() {} + +func NewWhen_then_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *When_then_clausesContext { + var p = new(When_then_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_when_then_clauses + + return p +} + +func (s *When_then_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *When_then_clausesContext) AllWHEN_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserWHEN_SYMBOL) +} + +func (s *When_then_clausesContext) WHEN_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWHEN_SYMBOL, i) +} + +func (s *When_then_clausesContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *When_then_clausesContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *When_then_clausesContext) AllTHEN_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserTHEN_SYMBOL) +} + +func (s *When_then_clausesContext) THEN_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTHEN_SYMBOL, i) +} + +func (s *When_then_clausesContext) AllStatement_list() []IStatement_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStatement_listContext); ok { + len++ + } + } + + tst := make([]IStatement_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStatement_listContext); ok { + tst[i] = t.(IStatement_listContext) + i++ + } + } + + return tst +} + +func (s *When_then_clausesContext) Statement_list(i int) IStatement_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatement_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStatement_listContext) +} + +func (s *When_then_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *When_then_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *When_then_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterWhen_then_clauses(s) + } +} + +func (s *When_then_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitWhen_then_clauses(s) + } +} + +func (s *When_then_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitWhen_then_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) When_then_clauses() (localctx IWhen_then_clausesContext) { + localctx = NewWhen_then_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 354, GoogleSQLParserRULE_when_then_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(2940) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == GoogleSQLParserWHEN_SYMBOL { + { + p.SetState(2934) + p.Match(GoogleSQLParserWHEN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2935) + p.expression(0) + } + { + p.SetState(2936) + p.Match(GoogleSQLParserTHEN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2938) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL || _la == GoogleSQLParserAT_SYMBOL || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-109078670720105279) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-1) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&284223755780095) != 0) || ((int64((_la-327)) & ^0x3f) == 0 && ((int64(1)<<(_la-327))&274340880385) != 0) { + { + p.SetState(2937) + p.Statement_list() + } + + } + + p.SetState(2942) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIf_statementContext is an interface to support dynamic dispatch. +type IIf_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllIF_SYMBOL() []antlr.TerminalNode + IF_SYMBOL(i int) antlr.TerminalNode + Expression() IExpressionContext + THEN_SYMBOL() antlr.TerminalNode + END_SYMBOL() antlr.TerminalNode + Statement_list() IStatement_listContext + Elseif_clauses() IElseif_clausesContext + Opt_else() IOpt_elseContext + + // IsIf_statementContext differentiates from other interfaces. + IsIf_statementContext() +} + +type If_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIf_statementContext() *If_statementContext { + var p = new(If_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_if_statement + return p +} + +func InitEmptyIf_statementContext(p *If_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_if_statement +} + +func (*If_statementContext) IsIf_statementContext() {} + +func NewIf_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *If_statementContext { + var p = new(If_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_if_statement + + return p +} + +func (s *If_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *If_statementContext) AllIF_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserIF_SYMBOL) +} + +func (s *If_statementContext) IF_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIF_SYMBOL, i) +} + +func (s *If_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *If_statementContext) THEN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTHEN_SYMBOL, 0) +} + +func (s *If_statementContext) END_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEND_SYMBOL, 0) +} + +func (s *If_statementContext) Statement_list() IStatement_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatement_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatement_listContext) +} + +func (s *If_statementContext) Elseif_clauses() IElseif_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IElseif_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IElseif_clausesContext) +} + +func (s *If_statementContext) Opt_else() IOpt_elseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_elseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_elseContext) +} + +func (s *If_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *If_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *If_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterIf_statement(s) + } +} + +func (s *If_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitIf_statement(s) + } +} + +func (s *If_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitIf_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) If_statement() (localctx IIf_statementContext) { + localctx = NewIf_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 356, GoogleSQLParserRULE_if_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2944) + p.Match(GoogleSQLParserIF_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2945) + p.expression(0) + } + { + p.SetState(2946) + p.Match(GoogleSQLParserTHEN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2948) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 300, p.GetParserRuleContext()) == 1 { + { + p.SetState(2947) + p.Statement_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2951) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserELSEIF_SYMBOL { + { + p.SetState(2950) + p.Elseif_clauses() + } + + } + p.SetState(2954) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserELSE_SYMBOL { + { + p.SetState(2953) + p.Opt_else() + } + + } + { + p.SetState(2956) + p.Match(GoogleSQLParserEND_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2957) + p.Match(GoogleSQLParserIF_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IElseif_clausesContext is an interface to support dynamic dispatch. +type IElseif_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllELSEIF_SYMBOL() []antlr.TerminalNode + ELSEIF_SYMBOL(i int) antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllTHEN_SYMBOL() []antlr.TerminalNode + THEN_SYMBOL(i int) antlr.TerminalNode + AllStatement_list() []IStatement_listContext + Statement_list(i int) IStatement_listContext + + // IsElseif_clausesContext differentiates from other interfaces. + IsElseif_clausesContext() +} + +type Elseif_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyElseif_clausesContext() *Elseif_clausesContext { + var p = new(Elseif_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_elseif_clauses + return p +} + +func InitEmptyElseif_clausesContext(p *Elseif_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_elseif_clauses +} + +func (*Elseif_clausesContext) IsElseif_clausesContext() {} + +func NewElseif_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Elseif_clausesContext { + var p = new(Elseif_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_elseif_clauses + + return p +} + +func (s *Elseif_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Elseif_clausesContext) AllELSEIF_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserELSEIF_SYMBOL) +} + +func (s *Elseif_clausesContext) ELSEIF_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserELSEIF_SYMBOL, i) +} + +func (s *Elseif_clausesContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Elseif_clausesContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Elseif_clausesContext) AllTHEN_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserTHEN_SYMBOL) +} + +func (s *Elseif_clausesContext) THEN_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTHEN_SYMBOL, i) +} + +func (s *Elseif_clausesContext) AllStatement_list() []IStatement_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStatement_listContext); ok { + len++ + } + } + + tst := make([]IStatement_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStatement_listContext); ok { + tst[i] = t.(IStatement_listContext) + i++ + } + } + + return tst +} + +func (s *Elseif_clausesContext) Statement_list(i int) IStatement_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatement_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStatement_listContext) +} + +func (s *Elseif_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Elseif_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Elseif_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterElseif_clauses(s) + } +} + +func (s *Elseif_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitElseif_clauses(s) + } +} + +func (s *Elseif_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitElseif_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Elseif_clauses() (localctx IElseif_clausesContext) { + localctx = NewElseif_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 358, GoogleSQLParserRULE_elseif_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(2965) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == GoogleSQLParserELSEIF_SYMBOL { + { + p.SetState(2959) + p.Match(GoogleSQLParserELSEIF_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2960) + p.expression(0) + } + { + p.SetState(2961) + p.Match(GoogleSQLParserTHEN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2963) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 303, p.GetParserRuleContext()) == 1 { + { + p.SetState(2962) + p.Statement_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + p.SetState(2967) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_elseContext is an interface to support dynamic dispatch. +type IOpt_elseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ELSE_SYMBOL() antlr.TerminalNode + Statement_list() IStatement_listContext + + // IsOpt_elseContext differentiates from other interfaces. + IsOpt_elseContext() +} + +type Opt_elseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_elseContext() *Opt_elseContext { + var p = new(Opt_elseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_else + return p +} + +func InitEmptyOpt_elseContext(p *Opt_elseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_else +} + +func (*Opt_elseContext) IsOpt_elseContext() {} + +func NewOpt_elseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_elseContext { + var p = new(Opt_elseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_else + + return p +} + +func (s *Opt_elseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_elseContext) ELSE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserELSE_SYMBOL, 0) +} + +func (s *Opt_elseContext) Statement_list() IStatement_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatement_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatement_listContext) +} + +func (s *Opt_elseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_elseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_elseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_else(s) + } +} + +func (s *Opt_elseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_else(s) + } +} + +func (s *Opt_elseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_else(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_else() (localctx IOpt_elseContext) { + localctx = NewOpt_elseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 360, GoogleSQLParserRULE_opt_else) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2969) + p.Match(GoogleSQLParserELSE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2971) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL || _la == GoogleSQLParserAT_SYMBOL || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-109078670720105279) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-1) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&284223755780095) != 0) || ((int64((_la-327)) & ^0x3f) == 0 && ((int64(1)<<(_la-327))&274340880385) != 0) { + { + p.SetState(2970) + p.Statement_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_as_codeContext is an interface to support dynamic dispatch. +type IOpt_as_codeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AS_SYMBOL() antlr.TerminalNode + String_literal() IString_literalContext + + // IsOpt_as_codeContext differentiates from other interfaces. + IsOpt_as_codeContext() +} + +type Opt_as_codeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_as_codeContext() *Opt_as_codeContext { + var p = new(Opt_as_codeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_as_code + return p +} + +func InitEmptyOpt_as_codeContext(p *Opt_as_codeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_as_code +} + +func (*Opt_as_codeContext) IsOpt_as_codeContext() {} + +func NewOpt_as_codeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_as_codeContext { + var p = new(Opt_as_codeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_as_code + + return p +} + +func (s *Opt_as_codeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_as_codeContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Opt_as_codeContext) String_literal() IString_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_literalContext) +} + +func (s *Opt_as_codeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_as_codeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_as_codeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_as_code(s) + } +} + +func (s *Opt_as_codeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_as_code(s) + } +} + +func (s *Opt_as_codeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_as_code(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_as_code() (localctx IOpt_as_codeContext) { + localctx = NewOpt_as_codeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 362, GoogleSQLParserRULE_opt_as_code) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2973) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2974) + p.string_literal(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_external_security_clauseContext is an interface to support dynamic dispatch. +type IOpt_external_security_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXTERNAL_SYMBOL() antlr.TerminalNode + SECURITY_SYMBOL() antlr.TerminalNode + External_security_clause_kind() IExternal_security_clause_kindContext + + // IsOpt_external_security_clauseContext differentiates from other interfaces. + IsOpt_external_security_clauseContext() +} + +type Opt_external_security_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_external_security_clauseContext() *Opt_external_security_clauseContext { + var p = new(Opt_external_security_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_external_security_clause + return p +} + +func InitEmptyOpt_external_security_clauseContext(p *Opt_external_security_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_external_security_clause +} + +func (*Opt_external_security_clauseContext) IsOpt_external_security_clauseContext() {} + +func NewOpt_external_security_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_external_security_clauseContext { + var p = new(Opt_external_security_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_external_security_clause + + return p +} + +func (s *Opt_external_security_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_external_security_clauseContext) EXTERNAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXTERNAL_SYMBOL, 0) +} + +func (s *Opt_external_security_clauseContext) SECURITY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSECURITY_SYMBOL, 0) +} + +func (s *Opt_external_security_clauseContext) External_security_clause_kind() IExternal_security_clause_kindContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_security_clause_kindContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_security_clause_kindContext) +} + +func (s *Opt_external_security_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_external_security_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_external_security_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_external_security_clause(s) + } +} + +func (s *Opt_external_security_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_external_security_clause(s) + } +} + +func (s *Opt_external_security_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_external_security_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_external_security_clause() (localctx IOpt_external_security_clauseContext) { + localctx = NewOpt_external_security_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 364, GoogleSQLParserRULE_opt_external_security_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2976) + p.Match(GoogleSQLParserEXTERNAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2977) + p.Match(GoogleSQLParserSECURITY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2978) + p.External_security_clause_kind() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_security_clause_kindContext is an interface to support dynamic dispatch. +type IExternal_security_clause_kindContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INVOKER_SYMBOL() antlr.TerminalNode + DEFINER_SYMBOL() antlr.TerminalNode + + // IsExternal_security_clause_kindContext differentiates from other interfaces. + IsExternal_security_clause_kindContext() +} + +type External_security_clause_kindContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_security_clause_kindContext() *External_security_clause_kindContext { + var p = new(External_security_clause_kindContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_external_security_clause_kind + return p +} + +func InitEmptyExternal_security_clause_kindContext(p *External_security_clause_kindContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_external_security_clause_kind +} + +func (*External_security_clause_kindContext) IsExternal_security_clause_kindContext() {} + +func NewExternal_security_clause_kindContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_security_clause_kindContext { + var p = new(External_security_clause_kindContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_external_security_clause_kind + + return p +} + +func (s *External_security_clause_kindContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_security_clause_kindContext) INVOKER_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINVOKER_SYMBOL, 0) +} + +func (s *External_security_clause_kindContext) DEFINER_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDEFINER_SYMBOL, 0) +} + +func (s *External_security_clause_kindContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_security_clause_kindContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_security_clause_kindContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterExternal_security_clause_kind(s) + } +} + +func (s *External_security_clause_kindContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitExternal_security_clause_kind(s) + } +} + +func (s *External_security_clause_kindContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitExternal_security_clause_kind(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) External_security_clause_kind() (localctx IExternal_security_clause_kindContext) { + localctx = NewExternal_security_clause_kindContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 366, GoogleSQLParserRULE_external_security_clause_kind) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2980) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserDEFINER_SYMBOL || _la == GoogleSQLParserINVOKER_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProcedure_parametersContext is an interface to support dynamic dispatch. +type IProcedure_parametersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + RR_BRACKET_SYMBOL() antlr.TerminalNode + AllProcedure_parameter() []IProcedure_parameterContext + Procedure_parameter(i int) IProcedure_parameterContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsProcedure_parametersContext differentiates from other interfaces. + IsProcedure_parametersContext() +} + +type Procedure_parametersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProcedure_parametersContext() *Procedure_parametersContext { + var p = new(Procedure_parametersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_procedure_parameters + return p +} + +func InitEmptyProcedure_parametersContext(p *Procedure_parametersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_procedure_parameters +} + +func (*Procedure_parametersContext) IsProcedure_parametersContext() {} + +func NewProcedure_parametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Procedure_parametersContext { + var p = new(Procedure_parametersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_procedure_parameters + + return p +} + +func (s *Procedure_parametersContext) GetParser() antlr.Parser { return s.parser } + +func (s *Procedure_parametersContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Procedure_parametersContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Procedure_parametersContext) AllProcedure_parameter() []IProcedure_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProcedure_parameterContext); ok { + len++ + } + } + + tst := make([]IProcedure_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProcedure_parameterContext); ok { + tst[i] = t.(IProcedure_parameterContext) + i++ + } + } + + return tst +} + +func (s *Procedure_parametersContext) Procedure_parameter(i int) IProcedure_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_parameterContext) +} + +func (s *Procedure_parametersContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Procedure_parametersContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Procedure_parametersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Procedure_parametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Procedure_parametersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterProcedure_parameters(s) + } +} + +func (s *Procedure_parametersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitProcedure_parameters(s) + } +} + +func (s *Procedure_parametersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitProcedure_parameters(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Procedure_parameters() (localctx IProcedure_parametersContext) { + localctx = NewProcedure_parametersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 368, GoogleSQLParserRULE_procedure_parameters) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2982) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2991) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&-213046430428157) != 0) || ((int64((_la-137)) & ^0x3f) == 0 && ((int64(1)<<(_la-137))&-1) != 0) || ((int64((_la-201)) & ^0x3f) == 0 && ((int64(1)<<(_la-201))&-72057594037927937) != 0) || ((int64((_la-265)) & ^0x3f) == 0 && ((int64(1)<<(_la-265))&1073741823) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&33488865) != 0) { + { + p.SetState(2983) + p.Procedure_parameter() + } + p.SetState(2988) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(2984) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2985) + p.Procedure_parameter() + } + + p.SetState(2990) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(2993) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProcedure_parameterContext is an interface to support dynamic dispatch. +type IProcedure_parameterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Type_or_tvf_schema() IType_or_tvf_schemaContext + Opt_procedure_parameter_mode() IOpt_procedure_parameter_modeContext + Procedure_parameter_termination() IProcedure_parameter_terminationContext + + // IsProcedure_parameterContext differentiates from other interfaces. + IsProcedure_parameterContext() +} + +type Procedure_parameterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProcedure_parameterContext() *Procedure_parameterContext { + var p = new(Procedure_parameterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_procedure_parameter + return p +} + +func InitEmptyProcedure_parameterContext(p *Procedure_parameterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_procedure_parameter +} + +func (*Procedure_parameterContext) IsProcedure_parameterContext() {} + +func NewProcedure_parameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Procedure_parameterContext { + var p = new(Procedure_parameterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_procedure_parameter + + return p +} + +func (s *Procedure_parameterContext) GetParser() antlr.Parser { return s.parser } + +func (s *Procedure_parameterContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Procedure_parameterContext) Type_or_tvf_schema() IType_or_tvf_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_or_tvf_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_or_tvf_schemaContext) +} + +func (s *Procedure_parameterContext) Opt_procedure_parameter_mode() IOpt_procedure_parameter_modeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_procedure_parameter_modeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_procedure_parameter_modeContext) +} + +func (s *Procedure_parameterContext) Procedure_parameter_termination() IProcedure_parameter_terminationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_parameter_terminationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_parameter_terminationContext) +} + +func (s *Procedure_parameterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Procedure_parameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Procedure_parameterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterProcedure_parameter(s) + } +} + +func (s *Procedure_parameterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitProcedure_parameter(s) + } +} + +func (s *Procedure_parameterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitProcedure_parameter(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Procedure_parameter() (localctx IProcedure_parameterContext) { + localctx = NewProcedure_parameterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 370, GoogleSQLParserRULE_procedure_parameter) + p.SetState(3008) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 310, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(2996) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 308, p.GetParserRuleContext()) == 1 { + { + p.SetState(2995) + p.Opt_procedure_parameter_mode() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2998) + p.Identifier() + } + { + p.SetState(2999) + p.Type_or_tvf_schema() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(3002) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 309, p.GetParserRuleContext()) == 1 { + { + p.SetState(3001) + p.Opt_procedure_parameter_mode() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3004) + p.Identifier() + } + { + p.SetState(3005) + p.Procedure_parameter_termination() + } + + p.NotifyErrorListeners("Syntax error: Unexpected end of parameter. Parameters should be in the format [] . If IN/OUT/INOUT is intended to be the name of a parameter, it must be escaped with backticks", nil, nil) + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProcedure_parameter_terminationContext is an interface to support dynamic dispatch. +type IProcedure_parameter_terminationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RR_BRACKET_SYMBOL() antlr.TerminalNode + COMMA_SYMBOL() antlr.TerminalNode + + // IsProcedure_parameter_terminationContext differentiates from other interfaces. + IsProcedure_parameter_terminationContext() +} + +type Procedure_parameter_terminationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProcedure_parameter_terminationContext() *Procedure_parameter_terminationContext { + var p = new(Procedure_parameter_terminationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_procedure_parameter_termination + return p +} + +func InitEmptyProcedure_parameter_terminationContext(p *Procedure_parameter_terminationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_procedure_parameter_termination +} + +func (*Procedure_parameter_terminationContext) IsProcedure_parameter_terminationContext() {} + +func NewProcedure_parameter_terminationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Procedure_parameter_terminationContext { + var p = new(Procedure_parameter_terminationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_procedure_parameter_termination + + return p +} + +func (s *Procedure_parameter_terminationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Procedure_parameter_terminationContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Procedure_parameter_terminationContext) COMMA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, 0) +} + +func (s *Procedure_parameter_terminationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Procedure_parameter_terminationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Procedure_parameter_terminationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterProcedure_parameter_termination(s) + } +} + +func (s *Procedure_parameter_terminationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitProcedure_parameter_termination(s) + } +} + +func (s *Procedure_parameter_terminationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitProcedure_parameter_termination(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Procedure_parameter_termination() (localctx IProcedure_parameter_terminationContext) { + localctx = NewProcedure_parameter_terminationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 372, GoogleSQLParserRULE_procedure_parameter_termination) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3010) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserCOMMA_SYMBOL || _la == GoogleSQLParserRR_BRACKET_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_procedure_parameter_modeContext is an interface to support dynamic dispatch. +type IOpt_procedure_parameter_modeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IN_SYMBOL() antlr.TerminalNode + OUT_SYMBOL() antlr.TerminalNode + INOUT_SYMBOL() antlr.TerminalNode + + // IsOpt_procedure_parameter_modeContext differentiates from other interfaces. + IsOpt_procedure_parameter_modeContext() +} + +type Opt_procedure_parameter_modeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_procedure_parameter_modeContext() *Opt_procedure_parameter_modeContext { + var p = new(Opt_procedure_parameter_modeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_procedure_parameter_mode + return p +} + +func InitEmptyOpt_procedure_parameter_modeContext(p *Opt_procedure_parameter_modeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_procedure_parameter_mode +} + +func (*Opt_procedure_parameter_modeContext) IsOpt_procedure_parameter_modeContext() {} + +func NewOpt_procedure_parameter_modeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_procedure_parameter_modeContext { + var p = new(Opt_procedure_parameter_modeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_procedure_parameter_mode + + return p +} + +func (s *Opt_procedure_parameter_modeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_procedure_parameter_modeContext) IN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIN_SYMBOL, 0) +} + +func (s *Opt_procedure_parameter_modeContext) OUT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOUT_SYMBOL, 0) +} + +func (s *Opt_procedure_parameter_modeContext) INOUT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINOUT_SYMBOL, 0) +} + +func (s *Opt_procedure_parameter_modeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_procedure_parameter_modeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_procedure_parameter_modeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_procedure_parameter_mode(s) + } +} + +func (s *Opt_procedure_parameter_modeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_procedure_parameter_mode(s) + } +} + +func (s *Opt_procedure_parameter_modeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_procedure_parameter_mode(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_procedure_parameter_mode() (localctx IOpt_procedure_parameter_modeContext) { + localctx = NewOpt_procedure_parameter_modeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 374, GoogleSQLParserRULE_opt_procedure_parameter_mode) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3012) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserIN_SYMBOL || _la == GoogleSQLParserINOUT_SYMBOL || _la == GoogleSQLParserOUT_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_function_statementContext is an interface to support dynamic dispatch. +type ICreate_function_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE_SYMBOL() antlr.TerminalNode + FUNCTION_SYMBOL() antlr.TerminalNode + Function_declaration() IFunction_declarationContext + Opt_or_replace() IOpt_or_replaceContext + Opt_create_scope() IOpt_create_scopeContext + Opt_aggregate() IOpt_aggregateContext + Opt_if_not_exists() IOpt_if_not_existsContext + Opt_function_returns() IOpt_function_returnsContext + Opt_sql_security_clause() IOpt_sql_security_clauseContext + Opt_determinism_level() IOpt_determinism_levelContext + Opt_language_or_remote_with_connection() IOpt_language_or_remote_with_connectionContext + Unordered_options_body() IUnordered_options_bodyContext + + // IsCreate_function_statementContext differentiates from other interfaces. + IsCreate_function_statementContext() +} + +type Create_function_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_function_statementContext() *Create_function_statementContext { + var p = new(Create_function_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_function_statement + return p +} + +func InitEmptyCreate_function_statementContext(p *Create_function_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_function_statement +} + +func (*Create_function_statementContext) IsCreate_function_statementContext() {} + +func NewCreate_function_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_function_statementContext { + var p = new(Create_function_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_create_function_statement + + return p +} + +func (s *Create_function_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_function_statementContext) CREATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCREATE_SYMBOL, 0) +} + +func (s *Create_function_statementContext) FUNCTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFUNCTION_SYMBOL, 0) +} + +func (s *Create_function_statementContext) Function_declaration() IFunction_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_declarationContext) +} + +func (s *Create_function_statementContext) Opt_or_replace() IOpt_or_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_replaceContext) +} + +func (s *Create_function_statementContext) Opt_create_scope() IOpt_create_scopeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_create_scopeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_create_scopeContext) +} + +func (s *Create_function_statementContext) Opt_aggregate() IOpt_aggregateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_aggregateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_aggregateContext) +} + +func (s *Create_function_statementContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *Create_function_statementContext) Opt_function_returns() IOpt_function_returnsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_function_returnsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_function_returnsContext) +} + +func (s *Create_function_statementContext) Opt_sql_security_clause() IOpt_sql_security_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_sql_security_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_sql_security_clauseContext) +} + +func (s *Create_function_statementContext) Opt_determinism_level() IOpt_determinism_levelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_determinism_levelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_determinism_levelContext) +} + +func (s *Create_function_statementContext) Opt_language_or_remote_with_connection() IOpt_language_or_remote_with_connectionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_language_or_remote_with_connectionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_language_or_remote_with_connectionContext) +} + +func (s *Create_function_statementContext) Unordered_options_body() IUnordered_options_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnordered_options_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnordered_options_bodyContext) +} + +func (s *Create_function_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_function_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_function_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCreate_function_statement(s) + } +} + +func (s *Create_function_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCreate_function_statement(s) + } +} + +func (s *Create_function_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCreate_function_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Create_function_statement() (localctx ICreate_function_statementContext) { + localctx = NewCreate_function_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 376, GoogleSQLParserRULE_create_function_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3014) + p.Match(GoogleSQLParserCREATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3016) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOR_SYMBOL { + { + p.SetState(3015) + p.Opt_or_replace() + } + + } + p.SetState(3019) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-226)) & ^0x3f) == 0 && ((int64(1)<<(_la-226))&105553116266529) != 0 { + { + p.SetState(3018) + p.Opt_create_scope() + } + + } + p.SetState(3022) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAGGREGATE_SYMBOL { + { + p.SetState(3021) + p.Opt_aggregate() + } + + } + { + p.SetState(3024) + p.Match(GoogleSQLParserFUNCTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3026) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(3025) + p.Opt_if_not_exists() + } + + } + { + p.SetState(3028) + p.Function_declaration() + } + p.SetState(3030) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserRETURNS_SYMBOL { + { + p.SetState(3029) + p.Opt_function_returns() + } + + } + p.SetState(3033) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserSQL_SYMBOL { + { + p.SetState(3032) + p.Opt_sql_security_clause() + } + + } + p.SetState(3036) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserNOT_SYMBOL || _la == GoogleSQLParserDETERMINISTIC_SYMBOL || _la == GoogleSQLParserIMMUTABLE_SYMBOL || _la == GoogleSQLParserSTABLE_SYMBOL || _la == GoogleSQLParserVOLATILE_SYMBOL { + { + p.SetState(3035) + p.Opt_determinism_level() + } + + } + p.SetState(3039) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWITH_SYMBOL || _la == GoogleSQLParserLANGUAGE_SYMBOL || _la == GoogleSQLParserREMOTE_SYMBOL { + { + p.SetState(3038) + p.Opt_language_or_remote_with_connection() + } + + } + p.SetState(3042) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL || _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(3041) + p.Unordered_options_body() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_determinism_levelContext is an interface to support dynamic dispatch. +type IOpt_determinism_levelContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DETERMINISTIC_SYMBOL() antlr.TerminalNode + NOT_SYMBOL() antlr.TerminalNode + IMMUTABLE_SYMBOL() antlr.TerminalNode + STABLE_SYMBOL() antlr.TerminalNode + VOLATILE_SYMBOL() antlr.TerminalNode + + // IsOpt_determinism_levelContext differentiates from other interfaces. + IsOpt_determinism_levelContext() +} + +type Opt_determinism_levelContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_determinism_levelContext() *Opt_determinism_levelContext { + var p = new(Opt_determinism_levelContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_determinism_level + return p +} + +func InitEmptyOpt_determinism_levelContext(p *Opt_determinism_levelContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_determinism_level +} + +func (*Opt_determinism_levelContext) IsOpt_determinism_levelContext() {} + +func NewOpt_determinism_levelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_determinism_levelContext { + var p = new(Opt_determinism_levelContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_determinism_level + + return p +} + +func (s *Opt_determinism_levelContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_determinism_levelContext) DETERMINISTIC_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDETERMINISTIC_SYMBOL, 0) +} + +func (s *Opt_determinism_levelContext) NOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNOT_SYMBOL, 0) +} + +func (s *Opt_determinism_levelContext) IMMUTABLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIMMUTABLE_SYMBOL, 0) +} + +func (s *Opt_determinism_levelContext) STABLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTABLE_SYMBOL, 0) +} + +func (s *Opt_determinism_levelContext) VOLATILE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserVOLATILE_SYMBOL, 0) +} + +func (s *Opt_determinism_levelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_determinism_levelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_determinism_levelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_determinism_level(s) + } +} + +func (s *Opt_determinism_levelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_determinism_level(s) + } +} + +func (s *Opt_determinism_levelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_determinism_level(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_determinism_level() (localctx IOpt_determinism_levelContext) { + localctx = NewOpt_determinism_levelContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 378, GoogleSQLParserRULE_opt_determinism_level) + p.SetState(3050) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserDETERMINISTIC_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3044) + p.Match(GoogleSQLParserDETERMINISTIC_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserNOT_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3045) + p.Match(GoogleSQLParserNOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3046) + p.Match(GoogleSQLParserDETERMINISTIC_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserIMMUTABLE_SYMBOL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3047) + p.Match(GoogleSQLParserIMMUTABLE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserSTABLE_SYMBOL: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3048) + p.Match(GoogleSQLParserSTABLE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserVOLATILE_SYMBOL: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3049) + p.Match(GoogleSQLParserVOLATILE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_sql_security_clauseContext is an interface to support dynamic dispatch. +type IOpt_sql_security_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SQL_SYMBOL() antlr.TerminalNode + SECURITY_SYMBOL() antlr.TerminalNode + Sql_security_clause_kind() ISql_security_clause_kindContext + + // IsOpt_sql_security_clauseContext differentiates from other interfaces. + IsOpt_sql_security_clauseContext() +} + +type Opt_sql_security_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_sql_security_clauseContext() *Opt_sql_security_clauseContext { + var p = new(Opt_sql_security_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_sql_security_clause + return p +} + +func InitEmptyOpt_sql_security_clauseContext(p *Opt_sql_security_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_sql_security_clause +} + +func (*Opt_sql_security_clauseContext) IsOpt_sql_security_clauseContext() {} + +func NewOpt_sql_security_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_sql_security_clauseContext { + var p = new(Opt_sql_security_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_sql_security_clause + + return p +} + +func (s *Opt_sql_security_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_sql_security_clauseContext) SQL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSQL_SYMBOL, 0) +} + +func (s *Opt_sql_security_clauseContext) SECURITY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSECURITY_SYMBOL, 0) +} + +func (s *Opt_sql_security_clauseContext) Sql_security_clause_kind() ISql_security_clause_kindContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_security_clause_kindContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_security_clause_kindContext) +} + +func (s *Opt_sql_security_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_sql_security_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_sql_security_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_sql_security_clause(s) + } +} + +func (s *Opt_sql_security_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_sql_security_clause(s) + } +} + +func (s *Opt_sql_security_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_sql_security_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_sql_security_clause() (localctx IOpt_sql_security_clauseContext) { + localctx = NewOpt_sql_security_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 380, GoogleSQLParserRULE_opt_sql_security_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3052) + p.Match(GoogleSQLParserSQL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3053) + p.Match(GoogleSQLParserSECURITY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3054) + p.Sql_security_clause_kind() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISql_security_clause_kindContext is an interface to support dynamic dispatch. +type ISql_security_clause_kindContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INVOKER_SYMBOL() antlr.TerminalNode + DEFINER_SYMBOL() antlr.TerminalNode + + // IsSql_security_clause_kindContext differentiates from other interfaces. + IsSql_security_clause_kindContext() +} + +type Sql_security_clause_kindContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySql_security_clause_kindContext() *Sql_security_clause_kindContext { + var p = new(Sql_security_clause_kindContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_sql_security_clause_kind + return p +} + +func InitEmptySql_security_clause_kindContext(p *Sql_security_clause_kindContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_sql_security_clause_kind +} + +func (*Sql_security_clause_kindContext) IsSql_security_clause_kindContext() {} + +func NewSql_security_clause_kindContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_security_clause_kindContext { + var p = new(Sql_security_clause_kindContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_sql_security_clause_kind + + return p +} + +func (s *Sql_security_clause_kindContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sql_security_clause_kindContext) INVOKER_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINVOKER_SYMBOL, 0) +} + +func (s *Sql_security_clause_kindContext) DEFINER_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDEFINER_SYMBOL, 0) +} + +func (s *Sql_security_clause_kindContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sql_security_clause_kindContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sql_security_clause_kindContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSql_security_clause_kind(s) + } +} + +func (s *Sql_security_clause_kindContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSql_security_clause_kind(s) + } +} + +func (s *Sql_security_clause_kindContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSql_security_clause_kind(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Sql_security_clause_kind() (localctx ISql_security_clause_kindContext) { + localctx = NewSql_security_clause_kindContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 382, GoogleSQLParserRULE_sql_security_clause_kind) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3056) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserDEFINER_SYMBOL || _la == GoogleSQLParserINVOKER_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAs_sql_function_body_or_stringContext is an interface to support dynamic dispatch. +type IAs_sql_function_body_or_stringContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AS_SYMBOL() antlr.TerminalNode + Sql_function_body() ISql_function_bodyContext + String_literal() IString_literalContext + + // IsAs_sql_function_body_or_stringContext differentiates from other interfaces. + IsAs_sql_function_body_or_stringContext() +} + +type As_sql_function_body_or_stringContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAs_sql_function_body_or_stringContext() *As_sql_function_body_or_stringContext { + var p = new(As_sql_function_body_or_stringContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_as_sql_function_body_or_string + return p +} + +func InitEmptyAs_sql_function_body_or_stringContext(p *As_sql_function_body_or_stringContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_as_sql_function_body_or_string +} + +func (*As_sql_function_body_or_stringContext) IsAs_sql_function_body_or_stringContext() {} + +func NewAs_sql_function_body_or_stringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *As_sql_function_body_or_stringContext { + var p = new(As_sql_function_body_or_stringContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_as_sql_function_body_or_string + + return p +} + +func (s *As_sql_function_body_or_stringContext) GetParser() antlr.Parser { return s.parser } + +func (s *As_sql_function_body_or_stringContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *As_sql_function_body_or_stringContext) Sql_function_body() ISql_function_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_function_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_function_bodyContext) +} + +func (s *As_sql_function_body_or_stringContext) String_literal() IString_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_literalContext) +} + +func (s *As_sql_function_body_or_stringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *As_sql_function_body_or_stringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *As_sql_function_body_or_stringContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterAs_sql_function_body_or_string(s) + } +} + +func (s *As_sql_function_body_or_stringContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitAs_sql_function_body_or_string(s) + } +} + +func (s *As_sql_function_body_or_stringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitAs_sql_function_body_or_string(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) As_sql_function_body_or_string() (localctx IAs_sql_function_body_or_stringContext) { + localctx = NewAs_sql_function_body_or_stringContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 384, GoogleSQLParserRULE_as_sql_function_body_or_string) + p.SetState(3062) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 321, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3058) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3059) + p.Sql_function_body() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3060) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3061) + p.string_literal(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISql_function_bodyContext is an interface to support dynamic dispatch. +type ISql_function_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + SELECT_SYMBOL() antlr.TerminalNode + + // IsSql_function_bodyContext differentiates from other interfaces. + IsSql_function_bodyContext() +} + +type Sql_function_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySql_function_bodyContext() *Sql_function_bodyContext { + var p = new(Sql_function_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_sql_function_body + return p +} + +func InitEmptySql_function_bodyContext(p *Sql_function_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_sql_function_body +} + +func (*Sql_function_bodyContext) IsSql_function_bodyContext() {} + +func NewSql_function_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_function_bodyContext { + var p = new(Sql_function_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_sql_function_body + + return p +} + +func (s *Sql_function_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sql_function_bodyContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Sql_function_bodyContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Sql_function_bodyContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Sql_function_bodyContext) SELECT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSELECT_SYMBOL, 0) +} + +func (s *Sql_function_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sql_function_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sql_function_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSql_function_body(s) + } +} + +func (s *Sql_function_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSql_function_body(s) + } +} + +func (s *Sql_function_bodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSql_function_body(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Sql_function_body() (localctx ISql_function_bodyContext) { + localctx = NewSql_function_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 386, GoogleSQLParserRULE_sql_function_body) + p.SetState(3071) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 322, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3064) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3065) + p.expression(0) + } + { + p.SetState(3066) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3068) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3069) + p.Match(GoogleSQLParserSELECT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.NotifyErrorListeners("The body of each CREATE FUNCTION statement is an expression, not a query; to use a query as an expression, the query must be wrapped with additional parentheses to make it a scalar subquery expression", nil, nil) + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnordered_options_bodyContext is an interface to support dynamic dispatch. +type IUnordered_options_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Opt_options_list() IOpt_options_listContext + As_sql_function_body_or_string() IAs_sql_function_body_or_stringContext + + // IsUnordered_options_bodyContext differentiates from other interfaces. + IsUnordered_options_bodyContext() +} + +type Unordered_options_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnordered_options_bodyContext() *Unordered_options_bodyContext { + var p = new(Unordered_options_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unordered_options_body + return p +} + +func InitEmptyUnordered_options_bodyContext(p *Unordered_options_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unordered_options_body +} + +func (*Unordered_options_bodyContext) IsUnordered_options_bodyContext() {} + +func NewUnordered_options_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unordered_options_bodyContext { + var p = new(Unordered_options_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_unordered_options_body + + return p +} + +func (s *Unordered_options_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unordered_options_bodyContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Unordered_options_bodyContext) As_sql_function_body_or_string() IAs_sql_function_body_or_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_sql_function_body_or_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_sql_function_body_or_stringContext) +} + +func (s *Unordered_options_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unordered_options_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unordered_options_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterUnordered_options_body(s) + } +} + +func (s *Unordered_options_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitUnordered_options_body(s) + } +} + +func (s *Unordered_options_bodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitUnordered_options_body(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Unordered_options_body() (localctx IUnordered_options_bodyContext) { + localctx = NewUnordered_options_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 388, GoogleSQLParserRULE_unordered_options_body) + var _la int + + p.SetState(3081) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserOPTIONS_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3073) + p.Opt_options_list() + } + p.SetState(3075) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(3074) + p.As_sql_function_body_or_string() + } + + } + + case GoogleSQLParserAS_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3077) + p.As_sql_function_body_or_string() + } + p.SetState(3079) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(3078) + p.Opt_options_list() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_language_or_remote_with_connectionContext is an interface to support dynamic dispatch. +type IOpt_language_or_remote_with_connectionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LANGUAGE_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + Remote_with_connection_clause() IRemote_with_connection_clauseContext + Language() ILanguageContext + + // IsOpt_language_or_remote_with_connectionContext differentiates from other interfaces. + IsOpt_language_or_remote_with_connectionContext() +} + +type Opt_language_or_remote_with_connectionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_language_or_remote_with_connectionContext() *Opt_language_or_remote_with_connectionContext { + var p = new(Opt_language_or_remote_with_connectionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_language_or_remote_with_connection + return p +} + +func InitEmptyOpt_language_or_remote_with_connectionContext(p *Opt_language_or_remote_with_connectionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_language_or_remote_with_connection +} + +func (*Opt_language_or_remote_with_connectionContext) IsOpt_language_or_remote_with_connectionContext() { +} + +func NewOpt_language_or_remote_with_connectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_language_or_remote_with_connectionContext { + var p = new(Opt_language_or_remote_with_connectionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_language_or_remote_with_connection + + return p +} + +func (s *Opt_language_or_remote_with_connectionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_language_or_remote_with_connectionContext) LANGUAGE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLANGUAGE_SYMBOL, 0) +} + +func (s *Opt_language_or_remote_with_connectionContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Opt_language_or_remote_with_connectionContext) Remote_with_connection_clause() IRemote_with_connection_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRemote_with_connection_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRemote_with_connection_clauseContext) +} + +func (s *Opt_language_or_remote_with_connectionContext) Language() ILanguageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILanguageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILanguageContext) +} + +func (s *Opt_language_or_remote_with_connectionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_language_or_remote_with_connectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_language_or_remote_with_connectionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_language_or_remote_with_connection(s) + } +} + +func (s *Opt_language_or_remote_with_connectionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_language_or_remote_with_connection(s) + } +} + +func (s *Opt_language_or_remote_with_connectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_language_or_remote_with_connection(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_language_or_remote_with_connection() (localctx IOpt_language_or_remote_with_connectionContext) { + localctx = NewOpt_language_or_remote_with_connectionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 390, GoogleSQLParserRULE_opt_language_or_remote_with_connection) + var _la int + + p.SetState(3092) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserLANGUAGE_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3083) + p.Match(GoogleSQLParserLANGUAGE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3084) + p.Identifier() + } + p.SetState(3086) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWITH_SYMBOL || _la == GoogleSQLParserREMOTE_SYMBOL { + { + p.SetState(3085) + p.Remote_with_connection_clause() + } + + } + + case GoogleSQLParserWITH_SYMBOL, GoogleSQLParserREMOTE_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3088) + p.Remote_with_connection_clause() + } + p.SetState(3090) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLANGUAGE_SYMBOL { + { + p.SetState(3089) + p.Language() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILanguageContext is an interface to support dynamic dispatch. +type ILanguageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LANGUAGE_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsLanguageContext differentiates from other interfaces. + IsLanguageContext() +} + +type LanguageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLanguageContext() *LanguageContext { + var p = new(LanguageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_language + return p +} + +func InitEmptyLanguageContext(p *LanguageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_language +} + +func (*LanguageContext) IsLanguageContext() {} + +func NewLanguageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LanguageContext { + var p = new(LanguageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_language + + return p +} + +func (s *LanguageContext) GetParser() antlr.Parser { return s.parser } + +func (s *LanguageContext) LANGUAGE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLANGUAGE_SYMBOL, 0) +} + +func (s *LanguageContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *LanguageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LanguageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LanguageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterLanguage(s) + } +} + +func (s *LanguageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitLanguage(s) + } +} + +func (s *LanguageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitLanguage(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Language() (localctx ILanguageContext) { + localctx = NewLanguageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 392, GoogleSQLParserRULE_language) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3094) + p.Match(GoogleSQLParserLANGUAGE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3095) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRemote_with_connection_clauseContext is an interface to support dynamic dispatch. +type IRemote_with_connection_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REMOTE_SYMBOL() antlr.TerminalNode + With_connection_clause() IWith_connection_clauseContext + + // IsRemote_with_connection_clauseContext differentiates from other interfaces. + IsRemote_with_connection_clauseContext() +} + +type Remote_with_connection_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRemote_with_connection_clauseContext() *Remote_with_connection_clauseContext { + var p = new(Remote_with_connection_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_remote_with_connection_clause + return p +} + +func InitEmptyRemote_with_connection_clauseContext(p *Remote_with_connection_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_remote_with_connection_clause +} + +func (*Remote_with_connection_clauseContext) IsRemote_with_connection_clauseContext() {} + +func NewRemote_with_connection_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Remote_with_connection_clauseContext { + var p = new(Remote_with_connection_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_remote_with_connection_clause + + return p +} + +func (s *Remote_with_connection_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Remote_with_connection_clauseContext) REMOTE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREMOTE_SYMBOL, 0) +} + +func (s *Remote_with_connection_clauseContext) With_connection_clause() IWith_connection_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_connection_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_connection_clauseContext) +} + +func (s *Remote_with_connection_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Remote_with_connection_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Remote_with_connection_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterRemote_with_connection_clause(s) + } +} + +func (s *Remote_with_connection_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitRemote_with_connection_clause(s) + } +} + +func (s *Remote_with_connection_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitRemote_with_connection_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Remote_with_connection_clause() (localctx IRemote_with_connection_clauseContext) { + localctx = NewRemote_with_connection_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 394, GoogleSQLParserRULE_remote_with_connection_clause) + var _la int + + p.SetState(3102) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserREMOTE_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3097) + p.Match(GoogleSQLParserREMOTE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3099) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWITH_SYMBOL { + { + p.SetState(3098) + p.With_connection_clause() + } + + } + + case GoogleSQLParserWITH_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3101) + p.With_connection_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWith_connection_clauseContext is an interface to support dynamic dispatch. +type IWith_connection_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH_SYMBOL() antlr.TerminalNode + Connection_clause() IConnection_clauseContext + + // IsWith_connection_clauseContext differentiates from other interfaces. + IsWith_connection_clauseContext() +} + +type With_connection_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWith_connection_clauseContext() *With_connection_clauseContext { + var p = new(With_connection_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_with_connection_clause + return p +} + +func InitEmptyWith_connection_clauseContext(p *With_connection_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_with_connection_clause +} + +func (*With_connection_clauseContext) IsWith_connection_clauseContext() {} + +func NewWith_connection_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_connection_clauseContext { + var p = new(With_connection_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_with_connection_clause + + return p +} + +func (s *With_connection_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *With_connection_clauseContext) WITH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWITH_SYMBOL, 0) +} + +func (s *With_connection_clauseContext) Connection_clause() IConnection_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConnection_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConnection_clauseContext) +} + +func (s *With_connection_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *With_connection_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *With_connection_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterWith_connection_clause(s) + } +} + +func (s *With_connection_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitWith_connection_clause(s) + } +} + +func (s *With_connection_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitWith_connection_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) With_connection_clause() (localctx IWith_connection_clauseContext) { + localctx = NewWith_connection_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 396, GoogleSQLParserRULE_with_connection_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3104) + p.Match(GoogleSQLParserWITH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3105) + p.Connection_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_function_returnsContext is an interface to support dynamic dispatch. +type IOpt_function_returnsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Opt_returns() IOpt_returnsContext + + // IsOpt_function_returnsContext differentiates from other interfaces. + IsOpt_function_returnsContext() +} + +type Opt_function_returnsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_function_returnsContext() *Opt_function_returnsContext { + var p = new(Opt_function_returnsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_function_returns + return p +} + +func InitEmptyOpt_function_returnsContext(p *Opt_function_returnsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_function_returns +} + +func (*Opt_function_returnsContext) IsOpt_function_returnsContext() {} + +func NewOpt_function_returnsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_function_returnsContext { + var p = new(Opt_function_returnsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_function_returns + + return p +} + +func (s *Opt_function_returnsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_function_returnsContext) Opt_returns() IOpt_returnsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_returnsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_returnsContext) +} + +func (s *Opt_function_returnsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_function_returnsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_function_returnsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_function_returns(s) + } +} + +func (s *Opt_function_returnsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_function_returns(s) + } +} + +func (s *Opt_function_returnsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_function_returns(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_function_returns() (localctx IOpt_function_returnsContext) { + localctx = NewOpt_function_returnsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 398, GoogleSQLParserRULE_opt_function_returns) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3107) + p.Opt_returns() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_returnsContext is an interface to support dynamic dispatch. +type IOpt_returnsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETURNS_SYMBOL() antlr.TerminalNode + Type_or_tvf_schema() IType_or_tvf_schemaContext + + // IsOpt_returnsContext differentiates from other interfaces. + IsOpt_returnsContext() +} + +type Opt_returnsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_returnsContext() *Opt_returnsContext { + var p = new(Opt_returnsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_returns + return p +} + +func InitEmptyOpt_returnsContext(p *Opt_returnsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_returns +} + +func (*Opt_returnsContext) IsOpt_returnsContext() {} + +func NewOpt_returnsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_returnsContext { + var p = new(Opt_returnsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_returns + + return p +} + +func (s *Opt_returnsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_returnsContext) RETURNS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRETURNS_SYMBOL, 0) +} + +func (s *Opt_returnsContext) Type_or_tvf_schema() IType_or_tvf_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_or_tvf_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_or_tvf_schemaContext) +} + +func (s *Opt_returnsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_returnsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_returnsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_returns(s) + } +} + +func (s *Opt_returnsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_returns(s) + } +} + +func (s *Opt_returnsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_returns(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_returns() (localctx IOpt_returnsContext) { + localctx = NewOpt_returnsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 400, GoogleSQLParserRULE_opt_returns) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3109) + p.Match(GoogleSQLParserRETURNS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3110) + p.Type_or_tvf_schema() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunction_declarationContext is an interface to support dynamic dispatch. +type IFunction_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Path_expression() IPath_expressionContext + Function_parameters() IFunction_parametersContext + + // IsFunction_declarationContext differentiates from other interfaces. + IsFunction_declarationContext() +} + +type Function_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_declarationContext() *Function_declarationContext { + var p = new(Function_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_function_declaration + return p +} + +func InitEmptyFunction_declarationContext(p *Function_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_function_declaration +} + +func (*Function_declarationContext) IsFunction_declarationContext() {} + +func NewFunction_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_declarationContext { + var p = new(Function_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_function_declaration + + return p +} + +func (s *Function_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_declarationContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Function_declarationContext) Function_parameters() IFunction_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_parametersContext) +} + +func (s *Function_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterFunction_declaration(s) + } +} + +func (s *Function_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitFunction_declaration(s) + } +} + +func (s *Function_declarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitFunction_declaration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Function_declaration() (localctx IFunction_declarationContext) { + localctx = NewFunction_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 402, GoogleSQLParserRULE_function_declaration) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3112) + p.Path_expression() + } + { + p.SetState(3113) + p.Function_parameters() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunction_parametersContext is an interface to support dynamic dispatch. +type IFunction_parametersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + RR_BRACKET_SYMBOL() antlr.TerminalNode + AllFunction_parameter() []IFunction_parameterContext + Function_parameter(i int) IFunction_parameterContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsFunction_parametersContext differentiates from other interfaces. + IsFunction_parametersContext() +} + +type Function_parametersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_parametersContext() *Function_parametersContext { + var p = new(Function_parametersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_function_parameters + return p +} + +func InitEmptyFunction_parametersContext(p *Function_parametersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_function_parameters +} + +func (*Function_parametersContext) IsFunction_parametersContext() {} + +func NewFunction_parametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_parametersContext { + var p = new(Function_parametersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_function_parameters + + return p +} + +func (s *Function_parametersContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_parametersContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Function_parametersContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Function_parametersContext) AllFunction_parameter() []IFunction_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunction_parameterContext); ok { + len++ + } + } + + tst := make([]IFunction_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunction_parameterContext); ok { + tst[i] = t.(IFunction_parameterContext) + i++ + } + } + + return tst +} + +func (s *Function_parametersContext) Function_parameter(i int) IFunction_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunction_parameterContext) +} + +func (s *Function_parametersContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Function_parametersContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Function_parametersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_parametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_parametersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterFunction_parameters(s) + } +} + +func (s *Function_parametersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitFunction_parameters(s) + } +} + +func (s *Function_parametersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitFunction_parameters(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Function_parameters() (localctx IFunction_parametersContext) { + localctx = NewFunction_parametersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 404, GoogleSQLParserRULE_function_parameters) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3115) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3124) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-56)) & ^0x3f) == 0 && ((int64(1)<<(_la-56))&-254304519003570175) != 0) || ((int64((_la-120)) & ^0x3f) == 0 && ((int64(1)<<(_la-120))&-1) != 0) || ((int64((_la-184)) & ^0x3f) == 0 && ((int64(1)<<(_la-184))&-1) != 0) || ((int64((_la-248)) & ^0x3f) == 0 && ((int64(1)<<(_la-248))&140737488354815) != 0) || ((int64((_la-333)) & ^0x3f) == 0 && ((int64(1)<<(_la-333))&4286574721) != 0) { + { + p.SetState(3116) + p.Function_parameter() + } + p.SetState(3121) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(3117) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3118) + p.Function_parameter() + } + + p.SetState(3123) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(3126) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunction_parameterContext is an interface to support dynamic dispatch. +type IFunction_parameterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Type_or_tvf_schema() IType_or_tvf_schemaContext + Opt_as_alias_with_required_as() IOpt_as_alias_with_required_asContext + Opt_default_expression() IOpt_default_expressionContext + Opt_not_aggregate() IOpt_not_aggregateContext + + // IsFunction_parameterContext differentiates from other interfaces. + IsFunction_parameterContext() +} + +type Function_parameterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_parameterContext() *Function_parameterContext { + var p = new(Function_parameterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_function_parameter + return p +} + +func InitEmptyFunction_parameterContext(p *Function_parameterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_function_parameter +} + +func (*Function_parameterContext) IsFunction_parameterContext() {} + +func NewFunction_parameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_parameterContext { + var p = new(Function_parameterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_function_parameter + + return p +} + +func (s *Function_parameterContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_parameterContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Function_parameterContext) Type_or_tvf_schema() IType_or_tvf_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_or_tvf_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_or_tvf_schemaContext) +} + +func (s *Function_parameterContext) Opt_as_alias_with_required_as() IOpt_as_alias_with_required_asContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_as_alias_with_required_asContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_as_alias_with_required_asContext) +} + +func (s *Function_parameterContext) Opt_default_expression() IOpt_default_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_default_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_default_expressionContext) +} + +func (s *Function_parameterContext) Opt_not_aggregate() IOpt_not_aggregateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_not_aggregateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_not_aggregateContext) +} + +func (s *Function_parameterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_parameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_parameterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterFunction_parameter(s) + } +} + +func (s *Function_parameterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitFunction_parameter(s) + } +} + +func (s *Function_parameterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitFunction_parameter(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Function_parameter() (localctx IFunction_parameterContext) { + localctx = NewFunction_parameterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 406, GoogleSQLParserRULE_function_parameter) + var _la int + + p.SetState(3146) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 338, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3128) + p.Identifier() + } + { + p.SetState(3129) + p.Type_or_tvf_schema() + } + p.SetState(3131) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(3130) + p.Opt_as_alias_with_required_as() + } + + } + p.SetState(3134) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserDEFAULT_SYMBOL { + { + p.SetState(3133) + p.Opt_default_expression() + } + + } + p.SetState(3137) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserNOT_SYMBOL { + { + p.SetState(3136) + p.Opt_not_aggregate() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3139) + p.Type_or_tvf_schema() + } + p.SetState(3141) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(3140) + p.Opt_as_alias_with_required_as() + } + + } + p.SetState(3144) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserNOT_SYMBOL { + { + p.SetState(3143) + p.Opt_not_aggregate() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_not_aggregateContext is an interface to support dynamic dispatch. +type IOpt_not_aggregateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOT_SYMBOL() antlr.TerminalNode + AGGREGATE_SYMBOL() antlr.TerminalNode + + // IsOpt_not_aggregateContext differentiates from other interfaces. + IsOpt_not_aggregateContext() +} + +type Opt_not_aggregateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_not_aggregateContext() *Opt_not_aggregateContext { + var p = new(Opt_not_aggregateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_not_aggregate + return p +} + +func InitEmptyOpt_not_aggregateContext(p *Opt_not_aggregateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_not_aggregate +} + +func (*Opt_not_aggregateContext) IsOpt_not_aggregateContext() {} + +func NewOpt_not_aggregateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_not_aggregateContext { + var p = new(Opt_not_aggregateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_not_aggregate + + return p +} + +func (s *Opt_not_aggregateContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_not_aggregateContext) NOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNOT_SYMBOL, 0) +} + +func (s *Opt_not_aggregateContext) AGGREGATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAGGREGATE_SYMBOL, 0) +} + +func (s *Opt_not_aggregateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_not_aggregateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_not_aggregateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_not_aggregate(s) + } +} + +func (s *Opt_not_aggregateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_not_aggregate(s) + } +} + +func (s *Opt_not_aggregateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_not_aggregate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_not_aggregate() (localctx IOpt_not_aggregateContext) { + localctx = NewOpt_not_aggregateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 408, GoogleSQLParserRULE_opt_not_aggregate) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3148) + p.Match(GoogleSQLParserNOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3149) + p.Match(GoogleSQLParserAGGREGATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_default_expressionContext is an interface to support dynamic dispatch. +type IOpt_default_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + + // IsOpt_default_expressionContext differentiates from other interfaces. + IsOpt_default_expressionContext() +} + +type Opt_default_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_default_expressionContext() *Opt_default_expressionContext { + var p = new(Opt_default_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_default_expression + return p +} + +func InitEmptyOpt_default_expressionContext(p *Opt_default_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_default_expression +} + +func (*Opt_default_expressionContext) IsOpt_default_expressionContext() {} + +func NewOpt_default_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_default_expressionContext { + var p = new(Opt_default_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_default_expression + + return p +} + +func (s *Opt_default_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_default_expressionContext) DEFAULT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDEFAULT_SYMBOL, 0) +} + +func (s *Opt_default_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Opt_default_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_default_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_default_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_default_expression(s) + } +} + +func (s *Opt_default_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_default_expression(s) + } +} + +func (s *Opt_default_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_default_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_default_expression() (localctx IOpt_default_expressionContext) { + localctx = NewOpt_default_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 410, GoogleSQLParserRULE_opt_default_expression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3151) + p.Match(GoogleSQLParserDEFAULT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3152) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IType_or_tvf_schemaContext is an interface to support dynamic dispatch. +type IType_or_tvf_schemaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Type_() ITypeContext + Templated_parameter_type() ITemplated_parameter_typeContext + Tvf_schema() ITvf_schemaContext + + // IsType_or_tvf_schemaContext differentiates from other interfaces. + IsType_or_tvf_schemaContext() +} + +type Type_or_tvf_schemaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_or_tvf_schemaContext() *Type_or_tvf_schemaContext { + var p = new(Type_or_tvf_schemaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_type_or_tvf_schema + return p +} + +func InitEmptyType_or_tvf_schemaContext(p *Type_or_tvf_schemaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_type_or_tvf_schema +} + +func (*Type_or_tvf_schemaContext) IsType_or_tvf_schemaContext() {} + +func NewType_or_tvf_schemaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_or_tvf_schemaContext { + var p = new(Type_or_tvf_schemaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_type_or_tvf_schema + + return p +} + +func (s *Type_or_tvf_schemaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_or_tvf_schemaContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *Type_or_tvf_schemaContext) Templated_parameter_type() ITemplated_parameter_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemplated_parameter_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemplated_parameter_typeContext) +} + +func (s *Type_or_tvf_schemaContext) Tvf_schema() ITvf_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITvf_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITvf_schemaContext) +} + +func (s *Type_or_tvf_schemaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_or_tvf_schemaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_or_tvf_schemaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterType_or_tvf_schema(s) + } +} + +func (s *Type_or_tvf_schemaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitType_or_tvf_schema(s) + } +} + +func (s *Type_or_tvf_schemaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitType_or_tvf_schema(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Type_or_tvf_schema() (localctx IType_or_tvf_schemaContext) { + localctx = NewType_or_tvf_schemaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 412, GoogleSQLParserRULE_type_or_tvf_schema) + p.SetState(3157) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 339, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3154) + p.Type_() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3155) + p.Templated_parameter_type() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3156) + p.Tvf_schema() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITvf_schemaContext is an interface to support dynamic dispatch. +type ITvf_schemaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLE_SYMBOL() antlr.TerminalNode + Template_type_open() ITemplate_type_openContext + AllTvf_schema_column() []ITvf_schema_columnContext + Tvf_schema_column(i int) ITvf_schema_columnContext + Template_type_close() ITemplate_type_closeContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsTvf_schemaContext differentiates from other interfaces. + IsTvf_schemaContext() +} + +type Tvf_schemaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTvf_schemaContext() *Tvf_schemaContext { + var p = new(Tvf_schemaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_tvf_schema + return p +} + +func InitEmptyTvf_schemaContext(p *Tvf_schemaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_tvf_schema +} + +func (*Tvf_schemaContext) IsTvf_schemaContext() {} + +func NewTvf_schemaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tvf_schemaContext { + var p = new(Tvf_schemaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_tvf_schema + + return p +} + +func (s *Tvf_schemaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tvf_schemaContext) TABLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTABLE_SYMBOL, 0) +} + +func (s *Tvf_schemaContext) Template_type_open() ITemplate_type_openContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemplate_type_openContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemplate_type_openContext) +} + +func (s *Tvf_schemaContext) AllTvf_schema_column() []ITvf_schema_columnContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITvf_schema_columnContext); ok { + len++ + } + } + + tst := make([]ITvf_schema_columnContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITvf_schema_columnContext); ok { + tst[i] = t.(ITvf_schema_columnContext) + i++ + } + } + + return tst +} + +func (s *Tvf_schemaContext) Tvf_schema_column(i int) ITvf_schema_columnContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITvf_schema_columnContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITvf_schema_columnContext) +} + +func (s *Tvf_schemaContext) Template_type_close() ITemplate_type_closeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemplate_type_closeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemplate_type_closeContext) +} + +func (s *Tvf_schemaContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Tvf_schemaContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Tvf_schemaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tvf_schemaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tvf_schemaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTvf_schema(s) + } +} + +func (s *Tvf_schemaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTvf_schema(s) + } +} + +func (s *Tvf_schemaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTvf_schema(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Tvf_schema() (localctx ITvf_schemaContext) { + localctx = NewTvf_schemaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 414, GoogleSQLParserRULE_tvf_schema) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3159) + p.Match(GoogleSQLParserTABLE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3160) + p.Template_type_open() + } + { + p.SetState(3161) + p.Tvf_schema_column() + } + p.SetState(3166) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(3162) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3163) + p.Tvf_schema_column() + } + + p.SetState(3168) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3169) + p.Template_type_close() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITvf_schema_columnContext is an interface to support dynamic dispatch. +type ITvf_schema_columnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Type_() ITypeContext + + // IsTvf_schema_columnContext differentiates from other interfaces. + IsTvf_schema_columnContext() +} + +type Tvf_schema_columnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTvf_schema_columnContext() *Tvf_schema_columnContext { + var p = new(Tvf_schema_columnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_tvf_schema_column + return p +} + +func InitEmptyTvf_schema_columnContext(p *Tvf_schema_columnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_tvf_schema_column +} + +func (*Tvf_schema_columnContext) IsTvf_schema_columnContext() {} + +func NewTvf_schema_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tvf_schema_columnContext { + var p = new(Tvf_schema_columnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_tvf_schema_column + + return p +} + +func (s *Tvf_schema_columnContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tvf_schema_columnContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Tvf_schema_columnContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *Tvf_schema_columnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tvf_schema_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tvf_schema_columnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTvf_schema_column(s) + } +} + +func (s *Tvf_schema_columnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTvf_schema_column(s) + } +} + +func (s *Tvf_schema_columnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTvf_schema_column(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Tvf_schema_column() (localctx ITvf_schema_columnContext) { + localctx = NewTvf_schema_columnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 416, GoogleSQLParserRULE_tvf_schema_column) + p.SetState(3175) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 341, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3171) + p.Identifier() + } + { + p.SetState(3172) + p.Type_() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3174) + p.Type_() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITemplated_parameter_typeContext is an interface to support dynamic dispatch. +type ITemplated_parameter_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ANY_SYMBOL() antlr.TerminalNode + Templated_parameter_kind() ITemplated_parameter_kindContext + + // IsTemplated_parameter_typeContext differentiates from other interfaces. + IsTemplated_parameter_typeContext() +} + +type Templated_parameter_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTemplated_parameter_typeContext() *Templated_parameter_typeContext { + var p = new(Templated_parameter_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_templated_parameter_type + return p +} + +func InitEmptyTemplated_parameter_typeContext(p *Templated_parameter_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_templated_parameter_type +} + +func (*Templated_parameter_typeContext) IsTemplated_parameter_typeContext() {} + +func NewTemplated_parameter_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Templated_parameter_typeContext { + var p = new(Templated_parameter_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_templated_parameter_type + + return p +} + +func (s *Templated_parameter_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Templated_parameter_typeContext) ANY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserANY_SYMBOL, 0) +} + +func (s *Templated_parameter_typeContext) Templated_parameter_kind() ITemplated_parameter_kindContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemplated_parameter_kindContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemplated_parameter_kindContext) +} + +func (s *Templated_parameter_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Templated_parameter_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Templated_parameter_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTemplated_parameter_type(s) + } +} + +func (s *Templated_parameter_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTemplated_parameter_type(s) + } +} + +func (s *Templated_parameter_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTemplated_parameter_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Templated_parameter_type() (localctx ITemplated_parameter_typeContext) { + localctx = NewTemplated_parameter_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 418, GoogleSQLParserRULE_templated_parameter_type) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3177) + p.Match(GoogleSQLParserANY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3178) + p.Templated_parameter_kind() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITemplated_parameter_kindContext is an interface to support dynamic dispatch. +type ITemplated_parameter_kindContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PROTO_SYMBOL() antlr.TerminalNode + ENUM_SYMBOL() antlr.TerminalNode + STRUCT_SYMBOL() antlr.TerminalNode + ARRAY_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsTemplated_parameter_kindContext differentiates from other interfaces. + IsTemplated_parameter_kindContext() +} + +type Templated_parameter_kindContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTemplated_parameter_kindContext() *Templated_parameter_kindContext { + var p = new(Templated_parameter_kindContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_templated_parameter_kind + return p +} + +func InitEmptyTemplated_parameter_kindContext(p *Templated_parameter_kindContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_templated_parameter_kind +} + +func (*Templated_parameter_kindContext) IsTemplated_parameter_kindContext() {} + +func NewTemplated_parameter_kindContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Templated_parameter_kindContext { + var p = new(Templated_parameter_kindContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_templated_parameter_kind + + return p +} + +func (s *Templated_parameter_kindContext) GetParser() antlr.Parser { return s.parser } + +func (s *Templated_parameter_kindContext) PROTO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPROTO_SYMBOL, 0) +} + +func (s *Templated_parameter_kindContext) ENUM_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserENUM_SYMBOL, 0) +} + +func (s *Templated_parameter_kindContext) STRUCT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTRUCT_SYMBOL, 0) +} + +func (s *Templated_parameter_kindContext) ARRAY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserARRAY_SYMBOL, 0) +} + +func (s *Templated_parameter_kindContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Templated_parameter_kindContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Templated_parameter_kindContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Templated_parameter_kindContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTemplated_parameter_kind(s) + } +} + +func (s *Templated_parameter_kindContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTemplated_parameter_kind(s) + } +} + +func (s *Templated_parameter_kindContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTemplated_parameter_kind(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Templated_parameter_kind() (localctx ITemplated_parameter_kindContext) { + localctx = NewTemplated_parameter_kindContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 420, GoogleSQLParserRULE_templated_parameter_kind) + p.SetState(3185) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserPROTO_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3180) + p.Match(GoogleSQLParserPROTO_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserENUM_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3181) + p.Match(GoogleSQLParserENUM_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserSTRUCT_SYMBOL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3182) + p.Match(GoogleSQLParserSTRUCT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserARRAY_SYMBOL: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3183) + p.Match(GoogleSQLParserARRAY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3184) + p.Identifier() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_aggregateContext is an interface to support dynamic dispatch. +type IOpt_aggregateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AGGREGATE_SYMBOL() antlr.TerminalNode + + // IsOpt_aggregateContext differentiates from other interfaces. + IsOpt_aggregateContext() +} + +type Opt_aggregateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_aggregateContext() *Opt_aggregateContext { + var p = new(Opt_aggregateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_aggregate + return p +} + +func InitEmptyOpt_aggregateContext(p *Opt_aggregateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_aggregate +} + +func (*Opt_aggregateContext) IsOpt_aggregateContext() {} + +func NewOpt_aggregateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_aggregateContext { + var p = new(Opt_aggregateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_aggregate + + return p +} + +func (s *Opt_aggregateContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_aggregateContext) AGGREGATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAGGREGATE_SYMBOL, 0) +} + +func (s *Opt_aggregateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_aggregateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_aggregateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_aggregate(s) + } +} + +func (s *Opt_aggregateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_aggregate(s) + } +} + +func (s *Opt_aggregateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_aggregate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_aggregate() (localctx IOpt_aggregateContext) { + localctx = NewOpt_aggregateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 422, GoogleSQLParserRULE_opt_aggregate) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3187) + p.Match(GoogleSQLParserAGGREGATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_database_statementContext is an interface to support dynamic dispatch. +type ICreate_database_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE_SYMBOL() antlr.TerminalNode + DATABASE_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + Opt_options_list() IOpt_options_listContext + + // IsCreate_database_statementContext differentiates from other interfaces. + IsCreate_database_statementContext() +} + +type Create_database_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_database_statementContext() *Create_database_statementContext { + var p = new(Create_database_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_database_statement + return p +} + +func InitEmptyCreate_database_statementContext(p *Create_database_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_database_statement +} + +func (*Create_database_statementContext) IsCreate_database_statementContext() {} + +func NewCreate_database_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_database_statementContext { + var p = new(Create_database_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_create_database_statement + + return p +} + +func (s *Create_database_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_database_statementContext) CREATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCREATE_SYMBOL, 0) +} + +func (s *Create_database_statementContext) DATABASE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDATABASE_SYMBOL, 0) +} + +func (s *Create_database_statementContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Create_database_statementContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Create_database_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_database_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_database_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCreate_database_statement(s) + } +} + +func (s *Create_database_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCreate_database_statement(s) + } +} + +func (s *Create_database_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCreate_database_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Create_database_statement() (localctx ICreate_database_statementContext) { + localctx = NewCreate_database_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 424, GoogleSQLParserRULE_create_database_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3189) + p.Match(GoogleSQLParserCREATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3190) + p.Match(GoogleSQLParserDATABASE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3191) + p.Path_expression() + } + p.SetState(3193) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(3192) + p.Opt_options_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_connection_statementContext is an interface to support dynamic dispatch. +type ICreate_connection_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE_SYMBOL() antlr.TerminalNode + CONNECTION_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + Opt_or_replace() IOpt_or_replaceContext + Opt_if_not_exists() IOpt_if_not_existsContext + Opt_options_list() IOpt_options_listContext + + // IsCreate_connection_statementContext differentiates from other interfaces. + IsCreate_connection_statementContext() +} + +type Create_connection_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_connection_statementContext() *Create_connection_statementContext { + var p = new(Create_connection_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_connection_statement + return p +} + +func InitEmptyCreate_connection_statementContext(p *Create_connection_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_connection_statement +} + +func (*Create_connection_statementContext) IsCreate_connection_statementContext() {} + +func NewCreate_connection_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_connection_statementContext { + var p = new(Create_connection_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_create_connection_statement + + return p +} + +func (s *Create_connection_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_connection_statementContext) CREATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCREATE_SYMBOL, 0) +} + +func (s *Create_connection_statementContext) CONNECTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCONNECTION_SYMBOL, 0) +} + +func (s *Create_connection_statementContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Create_connection_statementContext) Opt_or_replace() IOpt_or_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_replaceContext) +} + +func (s *Create_connection_statementContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *Create_connection_statementContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Create_connection_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_connection_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_connection_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCreate_connection_statement(s) + } +} + +func (s *Create_connection_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCreate_connection_statement(s) + } +} + +func (s *Create_connection_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCreate_connection_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Create_connection_statement() (localctx ICreate_connection_statementContext) { + localctx = NewCreate_connection_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 426, GoogleSQLParserRULE_create_connection_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3195) + p.Match(GoogleSQLParserCREATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3197) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOR_SYMBOL { + { + p.SetState(3196) + p.Opt_or_replace() + } + + } + { + p.SetState(3199) + p.Match(GoogleSQLParserCONNECTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3201) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(3200) + p.Opt_if_not_exists() + } + + } + { + p.SetState(3203) + p.Path_expression() + } + p.SetState(3205) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(3204) + p.Opt_options_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_constant_statementContext is an interface to support dynamic dispatch. +type ICreate_constant_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE_SYMBOL() antlr.TerminalNode + CONSTANT_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + EQUAL_OPERATOR() antlr.TerminalNode + Expression() IExpressionContext + Opt_or_replace() IOpt_or_replaceContext + Opt_create_scope() IOpt_create_scopeContext + Opt_if_not_exists() IOpt_if_not_existsContext + + // IsCreate_constant_statementContext differentiates from other interfaces. + IsCreate_constant_statementContext() +} + +type Create_constant_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_constant_statementContext() *Create_constant_statementContext { + var p = new(Create_constant_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_constant_statement + return p +} + +func InitEmptyCreate_constant_statementContext(p *Create_constant_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_create_constant_statement +} + +func (*Create_constant_statementContext) IsCreate_constant_statementContext() {} + +func NewCreate_constant_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_constant_statementContext { + var p = new(Create_constant_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_create_constant_statement + + return p +} + +func (s *Create_constant_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_constant_statementContext) CREATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCREATE_SYMBOL, 0) +} + +func (s *Create_constant_statementContext) CONSTANT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCONSTANT_SYMBOL, 0) +} + +func (s *Create_constant_statementContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Create_constant_statementContext) EQUAL_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEQUAL_OPERATOR, 0) +} + +func (s *Create_constant_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Create_constant_statementContext) Opt_or_replace() IOpt_or_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_replaceContext) +} + +func (s *Create_constant_statementContext) Opt_create_scope() IOpt_create_scopeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_create_scopeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_create_scopeContext) +} + +func (s *Create_constant_statementContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *Create_constant_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_constant_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_constant_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCreate_constant_statement(s) + } +} + +func (s *Create_constant_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCreate_constant_statement(s) + } +} + +func (s *Create_constant_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCreate_constant_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Create_constant_statement() (localctx ICreate_constant_statementContext) { + localctx = NewCreate_constant_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 428, GoogleSQLParserRULE_create_constant_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3207) + p.Match(GoogleSQLParserCREATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3209) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOR_SYMBOL { + { + p.SetState(3208) + p.Opt_or_replace() + } + + } + p.SetState(3212) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-226)) & ^0x3f) == 0 && ((int64(1)<<(_la-226))&105553116266529) != 0 { + { + p.SetState(3211) + p.Opt_create_scope() + } + + } + { + p.SetState(3214) + p.Match(GoogleSQLParserCONSTANT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3216) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(3215) + p.Opt_if_not_exists() + } + + } + { + p.SetState(3218) + p.Path_expression() + } + { + p.SetState(3219) + p.Match(GoogleSQLParserEQUAL_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3220) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_or_replaceContext is an interface to support dynamic dispatch. +type IOpt_or_replaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OR_SYMBOL() antlr.TerminalNode + REPLACE_SYMBOL() antlr.TerminalNode + + // IsOpt_or_replaceContext differentiates from other interfaces. + IsOpt_or_replaceContext() +} + +type Opt_or_replaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_or_replaceContext() *Opt_or_replaceContext { + var p = new(Opt_or_replaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_or_replace + return p +} + +func InitEmptyOpt_or_replaceContext(p *Opt_or_replaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_or_replace +} + +func (*Opt_or_replaceContext) IsOpt_or_replaceContext() {} + +func NewOpt_or_replaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_or_replaceContext { + var p = new(Opt_or_replaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_or_replace + + return p +} + +func (s *Opt_or_replaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_or_replaceContext) OR_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOR_SYMBOL, 0) +} + +func (s *Opt_or_replaceContext) REPLACE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREPLACE_SYMBOL, 0) +} + +func (s *Opt_or_replaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_or_replaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_or_replaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_or_replace(s) + } +} + +func (s *Opt_or_replaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_or_replace(s) + } +} + +func (s *Opt_or_replaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_or_replace(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_or_replace() (localctx IOpt_or_replaceContext) { + localctx = NewOpt_or_replaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 430, GoogleSQLParserRULE_opt_or_replace) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3222) + p.Match(GoogleSQLParserOR_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3223) + p.Match(GoogleSQLParserREPLACE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_create_scopeContext is an interface to support dynamic dispatch. +type IOpt_create_scopeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TEMP_SYMBOL() antlr.TerminalNode + TEMPORARY_SYMBOL() antlr.TerminalNode + PUBLIC_SYMBOL() antlr.TerminalNode + PRIVATE_SYMBOL() antlr.TerminalNode + + // IsOpt_create_scopeContext differentiates from other interfaces. + IsOpt_create_scopeContext() +} + +type Opt_create_scopeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_create_scopeContext() *Opt_create_scopeContext { + var p = new(Opt_create_scopeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_create_scope + return p +} + +func InitEmptyOpt_create_scopeContext(p *Opt_create_scopeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_create_scope +} + +func (*Opt_create_scopeContext) IsOpt_create_scopeContext() {} + +func NewOpt_create_scopeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_create_scopeContext { + var p = new(Opt_create_scopeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_create_scope + + return p +} + +func (s *Opt_create_scopeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_create_scopeContext) TEMP_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTEMP_SYMBOL, 0) +} + +func (s *Opt_create_scopeContext) TEMPORARY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTEMPORARY_SYMBOL, 0) +} + +func (s *Opt_create_scopeContext) PUBLIC_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPUBLIC_SYMBOL, 0) +} + +func (s *Opt_create_scopeContext) PRIVATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPRIVATE_SYMBOL, 0) +} + +func (s *Opt_create_scopeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_create_scopeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_create_scopeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_create_scope(s) + } +} + +func (s *Opt_create_scopeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_create_scope(s) + } +} + +func (s *Opt_create_scopeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_create_scope(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_create_scope() (localctx IOpt_create_scopeContext) { + localctx = NewOpt_create_scopeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 432, GoogleSQLParserRULE_opt_create_scope) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3225) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-226)) & ^0x3f) == 0 && ((int64(1)<<(_la-226))&105553116266529) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRun_batch_statementContext is an interface to support dynamic dispatch. +type IRun_batch_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RUN_SYMBOL() antlr.TerminalNode + BATCH_SYMBOL() antlr.TerminalNode + + // IsRun_batch_statementContext differentiates from other interfaces. + IsRun_batch_statementContext() +} + +type Run_batch_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRun_batch_statementContext() *Run_batch_statementContext { + var p = new(Run_batch_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_run_batch_statement + return p +} + +func InitEmptyRun_batch_statementContext(p *Run_batch_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_run_batch_statement +} + +func (*Run_batch_statementContext) IsRun_batch_statementContext() {} + +func NewRun_batch_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Run_batch_statementContext { + var p = new(Run_batch_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_run_batch_statement + + return p +} + +func (s *Run_batch_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Run_batch_statementContext) RUN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRUN_SYMBOL, 0) +} + +func (s *Run_batch_statementContext) BATCH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBATCH_SYMBOL, 0) +} + +func (s *Run_batch_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Run_batch_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Run_batch_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterRun_batch_statement(s) + } +} + +func (s *Run_batch_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitRun_batch_statement(s) + } +} + +func (s *Run_batch_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitRun_batch_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Run_batch_statement() (localctx IRun_batch_statementContext) { + localctx = NewRun_batch_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 434, GoogleSQLParserRULE_run_batch_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3227) + p.Match(GoogleSQLParserRUN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3228) + p.Match(GoogleSQLParserBATCH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAbort_batch_statementContext is an interface to support dynamic dispatch. +type IAbort_batch_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ABORT_SYMBOL() antlr.TerminalNode + BATCH_SYMBOL() antlr.TerminalNode + + // IsAbort_batch_statementContext differentiates from other interfaces. + IsAbort_batch_statementContext() +} + +type Abort_batch_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAbort_batch_statementContext() *Abort_batch_statementContext { + var p = new(Abort_batch_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_abort_batch_statement + return p +} + +func InitEmptyAbort_batch_statementContext(p *Abort_batch_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_abort_batch_statement +} + +func (*Abort_batch_statementContext) IsAbort_batch_statementContext() {} + +func NewAbort_batch_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Abort_batch_statementContext { + var p = new(Abort_batch_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_abort_batch_statement + + return p +} + +func (s *Abort_batch_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Abort_batch_statementContext) ABORT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserABORT_SYMBOL, 0) +} + +func (s *Abort_batch_statementContext) BATCH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBATCH_SYMBOL, 0) +} + +func (s *Abort_batch_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Abort_batch_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Abort_batch_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterAbort_batch_statement(s) + } +} + +func (s *Abort_batch_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitAbort_batch_statement(s) + } +} + +func (s *Abort_batch_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitAbort_batch_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Abort_batch_statement() (localctx IAbort_batch_statementContext) { + localctx = NewAbort_batch_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 436, GoogleSQLParserRULE_abort_batch_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3230) + p.Match(GoogleSQLParserABORT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3231) + p.Match(GoogleSQLParserBATCH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStart_batch_statementContext is an interface to support dynamic dispatch. +type IStart_batch_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + START_SYMBOL() antlr.TerminalNode + BATCH_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsStart_batch_statementContext differentiates from other interfaces. + IsStart_batch_statementContext() +} + +type Start_batch_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStart_batch_statementContext() *Start_batch_statementContext { + var p = new(Start_batch_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_start_batch_statement + return p +} + +func InitEmptyStart_batch_statementContext(p *Start_batch_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_start_batch_statement +} + +func (*Start_batch_statementContext) IsStart_batch_statementContext() {} + +func NewStart_batch_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Start_batch_statementContext { + var p = new(Start_batch_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_start_batch_statement + + return p +} + +func (s *Start_batch_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Start_batch_statementContext) START_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTART_SYMBOL, 0) +} + +func (s *Start_batch_statementContext) BATCH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBATCH_SYMBOL, 0) +} + +func (s *Start_batch_statementContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Start_batch_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Start_batch_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Start_batch_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterStart_batch_statement(s) + } +} + +func (s *Start_batch_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitStart_batch_statement(s) + } +} + +func (s *Start_batch_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitStart_batch_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Start_batch_statement() (localctx IStart_batch_statementContext) { + localctx = NewStart_batch_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 438, GoogleSQLParserRULE_start_batch_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3233) + p.Match(GoogleSQLParserSTART_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3234) + p.Match(GoogleSQLParserBATCH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3236) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-74)) & ^0x3f) == 0 && ((int64(1)<<(_la-74))&-106523215214079) != 0) || ((int64((_la-138)) & ^0x3f) == 0 && ((int64(1)<<(_la-138))&-1) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-36028797018963969) != 0) || ((int64((_la-266)) & ^0x3f) == 0 && ((int64(1)<<(_la-266))&536870911) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&33488865) != 0) { + { + p.SetState(3235) + p.Identifier() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRollback_statementContext is an interface to support dynamic dispatch. +type IRollback_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROLLBACK_SYMBOL() antlr.TerminalNode + TRANSACTION_SYMBOL() antlr.TerminalNode + + // IsRollback_statementContext differentiates from other interfaces. + IsRollback_statementContext() +} + +type Rollback_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRollback_statementContext() *Rollback_statementContext { + var p = new(Rollback_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_rollback_statement + return p +} + +func InitEmptyRollback_statementContext(p *Rollback_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_rollback_statement +} + +func (*Rollback_statementContext) IsRollback_statementContext() {} + +func NewRollback_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rollback_statementContext { + var p = new(Rollback_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_rollback_statement + + return p +} + +func (s *Rollback_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rollback_statementContext) ROLLBACK_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserROLLBACK_SYMBOL, 0) +} + +func (s *Rollback_statementContext) TRANSACTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTRANSACTION_SYMBOL, 0) +} + +func (s *Rollback_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rollback_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rollback_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterRollback_statement(s) + } +} + +func (s *Rollback_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitRollback_statement(s) + } +} + +func (s *Rollback_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitRollback_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Rollback_statement() (localctx IRollback_statementContext) { + localctx = NewRollback_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 440, GoogleSQLParserRULE_rollback_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3238) + p.Match(GoogleSQLParserROLLBACK_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3240) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserTRANSACTION_SYMBOL { + { + p.SetState(3239) + p.Match(GoogleSQLParserTRANSACTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICommit_statementContext is an interface to support dynamic dispatch. +type ICommit_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMIT_SYMBOL() antlr.TerminalNode + TRANSACTION_SYMBOL() antlr.TerminalNode + + // IsCommit_statementContext differentiates from other interfaces. + IsCommit_statementContext() +} + +type Commit_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCommit_statementContext() *Commit_statementContext { + var p = new(Commit_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_commit_statement + return p +} + +func InitEmptyCommit_statementContext(p *Commit_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_commit_statement +} + +func (*Commit_statementContext) IsCommit_statementContext() {} + +func NewCommit_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Commit_statementContext { + var p = new(Commit_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_commit_statement + + return p +} + +func (s *Commit_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Commit_statementContext) COMMIT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMIT_SYMBOL, 0) +} + +func (s *Commit_statementContext) TRANSACTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTRANSACTION_SYMBOL, 0) +} + +func (s *Commit_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Commit_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Commit_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCommit_statement(s) + } +} + +func (s *Commit_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCommit_statement(s) + } +} + +func (s *Commit_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCommit_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Commit_statement() (localctx ICommit_statementContext) { + localctx = NewCommit_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 442, GoogleSQLParserRULE_commit_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3242) + p.Match(GoogleSQLParserCOMMIT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3244) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserTRANSACTION_SYMBOL { + { + p.SetState(3243) + p.Match(GoogleSQLParserTRANSACTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISet_statementContext is an interface to support dynamic dispatch. +type ISet_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET_SYMBOL() antlr.TerminalNode + TRANSACTION_SYMBOL() antlr.TerminalNode + Transaction_mode_list() ITransaction_mode_listContext + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + EQUAL_OPERATOR() antlr.TerminalNode + Expression() IExpressionContext + Named_parameter_expression() INamed_parameter_expressionContext + System_variable_expression() ISystem_variable_expressionContext + LR_BRACKET_SYMBOL() antlr.TerminalNode + Identifier_list() IIdentifier_listContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + COMMA_SYMBOL() antlr.TerminalNode + + // IsSet_statementContext differentiates from other interfaces. + IsSet_statementContext() +} + +type Set_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_statementContext() *Set_statementContext { + var p = new(Set_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_set_statement + return p +} + +func InitEmptySet_statementContext(p *Set_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_set_statement +} + +func (*Set_statementContext) IsSet_statementContext() {} + +func NewSet_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_statementContext { + var p = new(Set_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_set_statement + + return p +} + +func (s *Set_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_statementContext) SET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSET_SYMBOL, 0) +} + +func (s *Set_statementContext) TRANSACTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTRANSACTION_SYMBOL, 0) +} + +func (s *Set_statementContext) Transaction_mode_list() ITransaction_mode_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransaction_mode_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITransaction_mode_listContext) +} + +func (s *Set_statementContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Set_statementContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Set_statementContext) EQUAL_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEQUAL_OPERATOR, 0) +} + +func (s *Set_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Set_statementContext) Named_parameter_expression() INamed_parameter_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INamed_parameter_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INamed_parameter_expressionContext) +} + +func (s *Set_statementContext) System_variable_expression() ISystem_variable_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISystem_variable_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISystem_variable_expressionContext) +} + +func (s *Set_statementContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Set_statementContext) Identifier_list() IIdentifier_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifier_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifier_listContext) +} + +func (s *Set_statementContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Set_statementContext) COMMA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, 0) +} + +func (s *Set_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSet_statement(s) + } +} + +func (s *Set_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSet_statement(s) + } +} + +func (s *Set_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSet_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Set_statement() (localctx ISet_statementContext) { + localctx = NewSet_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 444, GoogleSQLParserRULE_set_statement) + p.SetState(3278) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 353, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3246) + p.Match(GoogleSQLParserSET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3247) + p.Match(GoogleSQLParserTRANSACTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3248) + p.Transaction_mode_list() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3249) + p.Match(GoogleSQLParserSET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3250) + p.Identifier() + } + { + p.SetState(3251) + p.Match(GoogleSQLParserEQUAL_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3252) + p.expression(0) + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3254) + p.Match(GoogleSQLParserSET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3255) + p.Named_parameter_expression() + } + { + p.SetState(3256) + p.Match(GoogleSQLParserEQUAL_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3257) + p.expression(0) + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3259) + p.Match(GoogleSQLParserSET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3260) + p.System_variable_expression() + } + { + p.SetState(3261) + p.Match(GoogleSQLParserEQUAL_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3262) + p.expression(0) + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3264) + p.Match(GoogleSQLParserSET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3265) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3266) + p.Identifier_list() + } + { + p.SetState(3267) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3268) + p.Match(GoogleSQLParserEQUAL_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3269) + p.expression(0) + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3271) + p.Match(GoogleSQLParserSET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3272) + p.Identifier() + } + { + p.SetState(3273) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3274) + p.Identifier() + } + { + p.SetState(3275) + p.Match(GoogleSQLParserEQUAL_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.NotifyErrorListeners("Using SET with multiple variable required parentheses around the variable list", nil, nil) + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentifier_listContext is an interface to support dynamic dispatch. +type IIdentifier_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsIdentifier_listContext differentiates from other interfaces. + IsIdentifier_listContext() +} + +type Identifier_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentifier_listContext() *Identifier_listContext { + var p = new(Identifier_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_identifier_list + return p +} + +func InitEmptyIdentifier_listContext(p *Identifier_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_identifier_list +} + +func (*Identifier_listContext) IsIdentifier_listContext() {} + +func NewIdentifier_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Identifier_listContext { + var p = new(Identifier_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_identifier_list + + return p +} + +func (s *Identifier_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Identifier_listContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Identifier_listContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Identifier_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Identifier_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Identifier_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Identifier_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Identifier_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterIdentifier_list(s) + } +} + +func (s *Identifier_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitIdentifier_list(s) + } +} + +func (s *Identifier_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitIdentifier_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Identifier_list() (localctx IIdentifier_listContext) { + localctx = NewIdentifier_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 446, GoogleSQLParserRULE_identifier_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3280) + p.Identifier() + } + p.SetState(3285) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(3281) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3282) + p.Identifier() + } + + p.SetState(3287) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBegin_statementContext is an interface to support dynamic dispatch. +type IBegin_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Begin_transaction_keywords() IBegin_transaction_keywordsContext + Transaction_mode_list() ITransaction_mode_listContext + + // IsBegin_statementContext differentiates from other interfaces. + IsBegin_statementContext() +} + +type Begin_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBegin_statementContext() *Begin_statementContext { + var p = new(Begin_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_begin_statement + return p +} + +func InitEmptyBegin_statementContext(p *Begin_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_begin_statement +} + +func (*Begin_statementContext) IsBegin_statementContext() {} + +func NewBegin_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Begin_statementContext { + var p = new(Begin_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_begin_statement + + return p +} + +func (s *Begin_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Begin_statementContext) Begin_transaction_keywords() IBegin_transaction_keywordsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBegin_transaction_keywordsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBegin_transaction_keywordsContext) +} + +func (s *Begin_statementContext) Transaction_mode_list() ITransaction_mode_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransaction_mode_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITransaction_mode_listContext) +} + +func (s *Begin_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Begin_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Begin_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterBegin_statement(s) + } +} + +func (s *Begin_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitBegin_statement(s) + } +} + +func (s *Begin_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitBegin_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Begin_statement() (localctx IBegin_statementContext) { + localctx = NewBegin_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 448, GoogleSQLParserRULE_begin_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3288) + p.Begin_transaction_keywords() + } + p.SetState(3290) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserISOLATION_SYMBOL || _la == GoogleSQLParserREAD_SYMBOL { + { + p.SetState(3289) + p.Transaction_mode_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBegin_transaction_keywordsContext is an interface to support dynamic dispatch. +type IBegin_transaction_keywordsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + START_SYMBOL() antlr.TerminalNode + TRANSACTION_SYMBOL() antlr.TerminalNode + BEGIN_SYMBOL() antlr.TerminalNode + + // IsBegin_transaction_keywordsContext differentiates from other interfaces. + IsBegin_transaction_keywordsContext() +} + +type Begin_transaction_keywordsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBegin_transaction_keywordsContext() *Begin_transaction_keywordsContext { + var p = new(Begin_transaction_keywordsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_begin_transaction_keywords + return p +} + +func InitEmptyBegin_transaction_keywordsContext(p *Begin_transaction_keywordsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_begin_transaction_keywords +} + +func (*Begin_transaction_keywordsContext) IsBegin_transaction_keywordsContext() {} + +func NewBegin_transaction_keywordsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Begin_transaction_keywordsContext { + var p = new(Begin_transaction_keywordsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_begin_transaction_keywords + + return p +} + +func (s *Begin_transaction_keywordsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Begin_transaction_keywordsContext) START_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTART_SYMBOL, 0) +} + +func (s *Begin_transaction_keywordsContext) TRANSACTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTRANSACTION_SYMBOL, 0) +} + +func (s *Begin_transaction_keywordsContext) BEGIN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBEGIN_SYMBOL, 0) +} + +func (s *Begin_transaction_keywordsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Begin_transaction_keywordsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Begin_transaction_keywordsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterBegin_transaction_keywords(s) + } +} + +func (s *Begin_transaction_keywordsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitBegin_transaction_keywords(s) + } +} + +func (s *Begin_transaction_keywordsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitBegin_transaction_keywords(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Begin_transaction_keywords() (localctx IBegin_transaction_keywordsContext) { + localctx = NewBegin_transaction_keywordsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 450, GoogleSQLParserRULE_begin_transaction_keywords) + var _la int + + p.SetState(3298) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserSTART_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3292) + p.Match(GoogleSQLParserSTART_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3293) + p.Match(GoogleSQLParserTRANSACTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserBEGIN_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3294) + p.Match(GoogleSQLParserBEGIN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3296) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserTRANSACTION_SYMBOL { + { + p.SetState(3295) + p.Match(GoogleSQLParserTRANSACTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITransaction_mode_listContext is an interface to support dynamic dispatch. +type ITransaction_mode_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTransaction_mode() []ITransaction_modeContext + Transaction_mode(i int) ITransaction_modeContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsTransaction_mode_listContext differentiates from other interfaces. + IsTransaction_mode_listContext() +} + +type Transaction_mode_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTransaction_mode_listContext() *Transaction_mode_listContext { + var p = new(Transaction_mode_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_transaction_mode_list + return p +} + +func InitEmptyTransaction_mode_listContext(p *Transaction_mode_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_transaction_mode_list +} + +func (*Transaction_mode_listContext) IsTransaction_mode_listContext() {} + +func NewTransaction_mode_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transaction_mode_listContext { + var p = new(Transaction_mode_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_transaction_mode_list + + return p +} + +func (s *Transaction_mode_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Transaction_mode_listContext) AllTransaction_mode() []ITransaction_modeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITransaction_modeContext); ok { + len++ + } + } + + tst := make([]ITransaction_modeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITransaction_modeContext); ok { + tst[i] = t.(ITransaction_modeContext) + i++ + } + } + + return tst +} + +func (s *Transaction_mode_listContext) Transaction_mode(i int) ITransaction_modeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransaction_modeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITransaction_modeContext) +} + +func (s *Transaction_mode_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Transaction_mode_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Transaction_mode_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Transaction_mode_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Transaction_mode_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTransaction_mode_list(s) + } +} + +func (s *Transaction_mode_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTransaction_mode_list(s) + } +} + +func (s *Transaction_mode_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTransaction_mode_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Transaction_mode_list() (localctx ITransaction_mode_listContext) { + localctx = NewTransaction_mode_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 452, GoogleSQLParserRULE_transaction_mode_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3300) + p.Transaction_mode() + } + p.SetState(3305) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(3301) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3302) + p.Transaction_mode() + } + + p.SetState(3307) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITransaction_modeContext is an interface to support dynamic dispatch. +type ITransaction_modeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + READ_SYMBOL() antlr.TerminalNode + ONLY_SYMBOL() antlr.TerminalNode + WRITE_SYMBOL() antlr.TerminalNode + ISOLATION_SYMBOL() antlr.TerminalNode + LEVEL_SYMBOL() antlr.TerminalNode + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + + // IsTransaction_modeContext differentiates from other interfaces. + IsTransaction_modeContext() +} + +type Transaction_modeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTransaction_modeContext() *Transaction_modeContext { + var p = new(Transaction_modeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_transaction_mode + return p +} + +func InitEmptyTransaction_modeContext(p *Transaction_modeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_transaction_mode +} + +func (*Transaction_modeContext) IsTransaction_modeContext() {} + +func NewTransaction_modeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transaction_modeContext { + var p = new(Transaction_modeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_transaction_mode + + return p +} + +func (s *Transaction_modeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Transaction_modeContext) READ_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREAD_SYMBOL, 0) +} + +func (s *Transaction_modeContext) ONLY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserONLY_SYMBOL, 0) +} + +func (s *Transaction_modeContext) WRITE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWRITE_SYMBOL, 0) +} + +func (s *Transaction_modeContext) ISOLATION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserISOLATION_SYMBOL, 0) +} + +func (s *Transaction_modeContext) LEVEL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLEVEL_SYMBOL, 0) +} + +func (s *Transaction_modeContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Transaction_modeContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Transaction_modeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Transaction_modeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Transaction_modeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTransaction_mode(s) + } +} + +func (s *Transaction_modeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTransaction_mode(s) + } +} + +func (s *Transaction_modeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTransaction_mode(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Transaction_mode() (localctx ITransaction_modeContext) { + localctx = NewTransaction_modeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 454, GoogleSQLParserRULE_transaction_mode) + p.SetState(3320) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 359, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3308) + p.Match(GoogleSQLParserREAD_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3309) + p.Match(GoogleSQLParserONLY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3310) + p.Match(GoogleSQLParserREAD_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3311) + p.Match(GoogleSQLParserWRITE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3312) + p.Match(GoogleSQLParserISOLATION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3313) + p.Match(GoogleSQLParserLEVEL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3314) + p.Identifier() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3315) + p.Match(GoogleSQLParserISOLATION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3316) + p.Match(GoogleSQLParserLEVEL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3317) + p.Identifier() + } + { + p.SetState(3318) + p.Identifier() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITruncate_statementContext is an interface to support dynamic dispatch. +type ITruncate_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRUNCATE_SYMBOL() antlr.TerminalNode + TABLE_SYMBOL() antlr.TerminalNode + Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext + Opt_where_expression() IOpt_where_expressionContext + + // IsTruncate_statementContext differentiates from other interfaces. + IsTruncate_statementContext() +} + +type Truncate_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTruncate_statementContext() *Truncate_statementContext { + var p = new(Truncate_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_truncate_statement + return p +} + +func InitEmptyTruncate_statementContext(p *Truncate_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_truncate_statement +} + +func (*Truncate_statementContext) IsTruncate_statementContext() {} + +func NewTruncate_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Truncate_statementContext { + var p = new(Truncate_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_truncate_statement + + return p +} + +func (s *Truncate_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Truncate_statementContext) TRUNCATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTRUNCATE_SYMBOL, 0) +} + +func (s *Truncate_statementContext) TABLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTABLE_SYMBOL, 0) +} + +func (s *Truncate_statementContext) Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_dashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_dashed_path_expressionContext) +} + +func (s *Truncate_statementContext) Opt_where_expression() IOpt_where_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_where_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_where_expressionContext) +} + +func (s *Truncate_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Truncate_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Truncate_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTruncate_statement(s) + } +} + +func (s *Truncate_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTruncate_statement(s) + } +} + +func (s *Truncate_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTruncate_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Truncate_statement() (localctx ITruncate_statementContext) { + localctx = NewTruncate_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 456, GoogleSQLParserRULE_truncate_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3322) + p.Match(GoogleSQLParserTRUNCATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3323) + p.Match(GoogleSQLParserTABLE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3324) + p.Maybe_dashed_path_expression() + } + p.SetState(3326) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWHERE_SYMBOL { + { + p.SetState(3325) + p.Opt_where_expression() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMerge_statementContext is an interface to support dynamic dispatch. +type IMerge_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MERGE_SYMBOL() antlr.TerminalNode + Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext + USING_SYMBOL() antlr.TerminalNode + Merge_source() IMerge_sourceContext + ON_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + INTO_SYMBOL() antlr.TerminalNode + As_alias() IAs_aliasContext + AllMerge_when_clause() []IMerge_when_clauseContext + Merge_when_clause(i int) IMerge_when_clauseContext + + // IsMerge_statementContext differentiates from other interfaces. + IsMerge_statementContext() +} + +type Merge_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_statementContext() *Merge_statementContext { + var p = new(Merge_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_merge_statement + return p +} + +func InitEmptyMerge_statementContext(p *Merge_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_merge_statement +} + +func (*Merge_statementContext) IsMerge_statementContext() {} + +func NewMerge_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_statementContext { + var p = new(Merge_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_merge_statement + + return p +} + +func (s *Merge_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_statementContext) MERGE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMERGE_SYMBOL, 0) +} + +func (s *Merge_statementContext) Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_dashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_dashed_path_expressionContext) +} + +func (s *Merge_statementContext) USING_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUSING_SYMBOL, 0) +} + +func (s *Merge_statementContext) Merge_source() IMerge_sourceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_sourceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_sourceContext) +} + +func (s *Merge_statementContext) ON_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserON_SYMBOL, 0) +} + +func (s *Merge_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Merge_statementContext) INTO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINTO_SYMBOL, 0) +} + +func (s *Merge_statementContext) As_alias() IAs_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_aliasContext) +} + +func (s *Merge_statementContext) AllMerge_when_clause() []IMerge_when_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMerge_when_clauseContext); ok { + len++ + } + } + + tst := make([]IMerge_when_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMerge_when_clauseContext); ok { + tst[i] = t.(IMerge_when_clauseContext) + i++ + } + } + + return tst +} + +func (s *Merge_statementContext) Merge_when_clause(i int) IMerge_when_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_when_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMerge_when_clauseContext) +} + +func (s *Merge_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterMerge_statement(s) + } +} + +func (s *Merge_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitMerge_statement(s) + } +} + +func (s *Merge_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitMerge_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Merge_statement() (localctx IMerge_statementContext) { + localctx = NewMerge_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 458, GoogleSQLParserRULE_merge_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3328) + p.Match(GoogleSQLParserMERGE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3330) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserINTO_SYMBOL { + { + p.SetState(3329) + p.Match(GoogleSQLParserINTO_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3332) + p.Maybe_dashed_path_expression() + } + p.SetState(3334) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-58)) & ^0x3f) == 0 && ((int64(1)<<(_la-58))&-6981105432269881343) != 0) || ((int64((_la-122)) & ^0x3f) == 0 && ((int64(1)<<(_la-122))&-1) != 0) || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&-1) != 0) || ((int64((_la-250)) & ^0x3f) == 0 && ((int64(1)<<(_la-250))&35184372088703) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&33488865) != 0) { + { + p.SetState(3333) + p.As_alias() + } + + } + { + p.SetState(3336) + p.Match(GoogleSQLParserUSING_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3337) + p.Merge_source() + } + { + p.SetState(3338) + p.Match(GoogleSQLParserON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3339) + p.expression(0) + } + p.SetState(3341) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == GoogleSQLParserWHEN_SYMBOL { + { + p.SetState(3340) + p.Merge_when_clause() + } + + p.SetState(3343) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMerge_sourceContext is an interface to support dynamic dispatch. +type IMerge_sourceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_path_expression() ITable_path_expressionContext + Table_subquery() ITable_subqueryContext + + // IsMerge_sourceContext differentiates from other interfaces. + IsMerge_sourceContext() +} + +type Merge_sourceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_sourceContext() *Merge_sourceContext { + var p = new(Merge_sourceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_merge_source + return p +} + +func InitEmptyMerge_sourceContext(p *Merge_sourceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_merge_source +} + +func (*Merge_sourceContext) IsMerge_sourceContext() {} + +func NewMerge_sourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_sourceContext { + var p = new(Merge_sourceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_merge_source + + return p +} + +func (s *Merge_sourceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_sourceContext) Table_path_expression() ITable_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_path_expressionContext) +} + +func (s *Merge_sourceContext) Table_subquery() ITable_subqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_subqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_subqueryContext) +} + +func (s *Merge_sourceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_sourceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_sourceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterMerge_source(s) + } +} + +func (s *Merge_sourceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitMerge_source(s) + } +} + +func (s *Merge_sourceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitMerge_source(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Merge_source() (localctx IMerge_sourceContext) { + localctx = NewMerge_sourceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 460, GoogleSQLParserRULE_merge_source) + p.SetState(3347) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserUNNEST_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserSLASH_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3345) + p.Table_path_expression() + } + + case GoogleSQLParserLR_BRACKET_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3346) + p.Table_subquery() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMerge_when_clauseContext is an interface to support dynamic dispatch. +type IMerge_when_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN_SYMBOL() antlr.TerminalNode + MATCHED_SYMBOL() antlr.TerminalNode + THEN_SYMBOL() antlr.TerminalNode + Merge_action() IMerge_actionContext + Opt_and_expression() IOpt_and_expressionContext + NOT_SYMBOL() antlr.TerminalNode + By_target() IBy_targetContext + BY_SYMBOL() antlr.TerminalNode + SOURCE_SYMBOL() antlr.TerminalNode + + // IsMerge_when_clauseContext differentiates from other interfaces. + IsMerge_when_clauseContext() +} + +type Merge_when_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_when_clauseContext() *Merge_when_clauseContext { + var p = new(Merge_when_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_merge_when_clause + return p +} + +func InitEmptyMerge_when_clauseContext(p *Merge_when_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_merge_when_clause +} + +func (*Merge_when_clauseContext) IsMerge_when_clauseContext() {} + +func NewMerge_when_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_when_clauseContext { + var p = new(Merge_when_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_merge_when_clause + + return p +} + +func (s *Merge_when_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_when_clauseContext) WHEN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWHEN_SYMBOL, 0) +} + +func (s *Merge_when_clauseContext) MATCHED_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMATCHED_SYMBOL, 0) +} + +func (s *Merge_when_clauseContext) THEN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTHEN_SYMBOL, 0) +} + +func (s *Merge_when_clauseContext) Merge_action() IMerge_actionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_actionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_actionContext) +} + +func (s *Merge_when_clauseContext) Opt_and_expression() IOpt_and_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_and_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_and_expressionContext) +} + +func (s *Merge_when_clauseContext) NOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNOT_SYMBOL, 0) +} + +func (s *Merge_when_clauseContext) By_target() IBy_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBy_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBy_targetContext) +} + +func (s *Merge_when_clauseContext) BY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBY_SYMBOL, 0) +} + +func (s *Merge_when_clauseContext) SOURCE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSOURCE_SYMBOL, 0) +} + +func (s *Merge_when_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_when_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_when_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterMerge_when_clause(s) + } +} + +func (s *Merge_when_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitMerge_when_clause(s) + } +} + +func (s *Merge_when_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitMerge_when_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Merge_when_clause() (localctx IMerge_when_clauseContext) { + localctx = NewMerge_when_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 462, GoogleSQLParserRULE_merge_when_clause) + var _la int + + p.SetState(3377) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 369, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3349) + p.Match(GoogleSQLParserWHEN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3350) + p.Match(GoogleSQLParserMATCHED_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3352) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAND_SYMBOL { + { + p.SetState(3351) + p.Opt_and_expression() + } + + } + { + p.SetState(3354) + p.Match(GoogleSQLParserTHEN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3355) + p.Merge_action() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3356) + p.Match(GoogleSQLParserWHEN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3357) + p.Match(GoogleSQLParserNOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3358) + p.Match(GoogleSQLParserMATCHED_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3360) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserBY_SYMBOL { + { + p.SetState(3359) + p.By_target() + } + + } + p.SetState(3363) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAND_SYMBOL { + { + p.SetState(3362) + p.Opt_and_expression() + } + + } + { + p.SetState(3365) + p.Match(GoogleSQLParserTHEN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3366) + p.Merge_action() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3367) + p.Match(GoogleSQLParserWHEN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3368) + p.Match(GoogleSQLParserNOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3369) + p.Match(GoogleSQLParserMATCHED_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3370) + p.Match(GoogleSQLParserBY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3371) + p.Match(GoogleSQLParserSOURCE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3373) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAND_SYMBOL { + { + p.SetState(3372) + p.Opt_and_expression() + } + + } + { + p.SetState(3375) + p.Match(GoogleSQLParserTHEN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3376) + p.Merge_action() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMerge_actionContext is an interface to support dynamic dispatch. +type IMerge_actionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INSERT_SYMBOL() antlr.TerminalNode + Merge_insert_value_list_or_source_row() IMerge_insert_value_list_or_source_rowContext + Column_list() IColumn_listContext + UPDATE_SYMBOL() antlr.TerminalNode + SET_SYMBOL() antlr.TerminalNode + Update_item_list() IUpdate_item_listContext + DELETE_SYMBOL() antlr.TerminalNode + + // IsMerge_actionContext differentiates from other interfaces. + IsMerge_actionContext() +} + +type Merge_actionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_actionContext() *Merge_actionContext { + var p = new(Merge_actionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_merge_action + return p +} + +func InitEmptyMerge_actionContext(p *Merge_actionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_merge_action +} + +func (*Merge_actionContext) IsMerge_actionContext() {} + +func NewMerge_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_actionContext { + var p = new(Merge_actionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_merge_action + + return p +} + +func (s *Merge_actionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_actionContext) INSERT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINSERT_SYMBOL, 0) +} + +func (s *Merge_actionContext) Merge_insert_value_list_or_source_row() IMerge_insert_value_list_or_source_rowContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_insert_value_list_or_source_rowContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_insert_value_list_or_source_rowContext) +} + +func (s *Merge_actionContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Merge_actionContext) UPDATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUPDATE_SYMBOL, 0) +} + +func (s *Merge_actionContext) SET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSET_SYMBOL, 0) +} + +func (s *Merge_actionContext) Update_item_list() IUpdate_item_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_item_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_item_listContext) +} + +func (s *Merge_actionContext) DELETE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDELETE_SYMBOL, 0) +} + +func (s *Merge_actionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_actionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterMerge_action(s) + } +} + +func (s *Merge_actionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitMerge_action(s) + } +} + +func (s *Merge_actionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitMerge_action(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Merge_action() (localctx IMerge_actionContext) { + localctx = NewMerge_actionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 464, GoogleSQLParserRULE_merge_action) + var _la int + + p.SetState(3388) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserINSERT_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3379) + p.Match(GoogleSQLParserINSERT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3381) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL { + { + p.SetState(3380) + p.Column_list() + } + + } + { + p.SetState(3383) + p.Merge_insert_value_list_or_source_row() + } + + case GoogleSQLParserUPDATE_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3384) + p.Match(GoogleSQLParserUPDATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3385) + p.Match(GoogleSQLParserSET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3386) + p.Update_item_list() + } + + case GoogleSQLParserDELETE_SYMBOL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3387) + p.Match(GoogleSQLParserDELETE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMerge_insert_value_list_or_source_rowContext is an interface to support dynamic dispatch. +type IMerge_insert_value_list_or_source_rowContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VALUES_SYMBOL() antlr.TerminalNode + Insert_values_row() IInsert_values_rowContext + ROW_SYMBOL() antlr.TerminalNode + + // IsMerge_insert_value_list_or_source_rowContext differentiates from other interfaces. + IsMerge_insert_value_list_or_source_rowContext() +} + +type Merge_insert_value_list_or_source_rowContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_insert_value_list_or_source_rowContext() *Merge_insert_value_list_or_source_rowContext { + var p = new(Merge_insert_value_list_or_source_rowContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_merge_insert_value_list_or_source_row + return p +} + +func InitEmptyMerge_insert_value_list_or_source_rowContext(p *Merge_insert_value_list_or_source_rowContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_merge_insert_value_list_or_source_row +} + +func (*Merge_insert_value_list_or_source_rowContext) IsMerge_insert_value_list_or_source_rowContext() { +} + +func NewMerge_insert_value_list_or_source_rowContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_insert_value_list_or_source_rowContext { + var p = new(Merge_insert_value_list_or_source_rowContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_merge_insert_value_list_or_source_row + + return p +} + +func (s *Merge_insert_value_list_or_source_rowContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_insert_value_list_or_source_rowContext) VALUES_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserVALUES_SYMBOL, 0) +} + +func (s *Merge_insert_value_list_or_source_rowContext) Insert_values_row() IInsert_values_rowContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_values_rowContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsert_values_rowContext) +} + +func (s *Merge_insert_value_list_or_source_rowContext) ROW_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserROW_SYMBOL, 0) +} + +func (s *Merge_insert_value_list_or_source_rowContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_insert_value_list_or_source_rowContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_insert_value_list_or_source_rowContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterMerge_insert_value_list_or_source_row(s) + } +} + +func (s *Merge_insert_value_list_or_source_rowContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitMerge_insert_value_list_or_source_row(s) + } +} + +func (s *Merge_insert_value_list_or_source_rowContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitMerge_insert_value_list_or_source_row(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Merge_insert_value_list_or_source_row() (localctx IMerge_insert_value_list_or_source_rowContext) { + localctx = NewMerge_insert_value_list_or_source_rowContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 466, GoogleSQLParserRULE_merge_insert_value_list_or_source_row) + p.SetState(3393) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserVALUES_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3390) + p.Match(GoogleSQLParserVALUES_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3391) + p.Insert_values_row() + } + + case GoogleSQLParserROW_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3392) + p.Match(GoogleSQLParserROW_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBy_targetContext is an interface to support dynamic dispatch. +type IBy_targetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BY_SYMBOL() antlr.TerminalNode + TARGET_SYMBOL() antlr.TerminalNode + + // IsBy_targetContext differentiates from other interfaces. + IsBy_targetContext() +} + +type By_targetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBy_targetContext() *By_targetContext { + var p = new(By_targetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_by_target + return p +} + +func InitEmptyBy_targetContext(p *By_targetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_by_target +} + +func (*By_targetContext) IsBy_targetContext() {} + +func NewBy_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *By_targetContext { + var p = new(By_targetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_by_target + + return p +} + +func (s *By_targetContext) GetParser() antlr.Parser { return s.parser } + +func (s *By_targetContext) BY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBY_SYMBOL, 0) +} + +func (s *By_targetContext) TARGET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTARGET_SYMBOL, 0) +} + +func (s *By_targetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *By_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *By_targetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterBy_target(s) + } +} + +func (s *By_targetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitBy_target(s) + } +} + +func (s *By_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitBy_target(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) By_target() (localctx IBy_targetContext) { + localctx = NewBy_targetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 468, GoogleSQLParserRULE_by_target) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3395) + p.Match(GoogleSQLParserBY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3396) + p.Match(GoogleSQLParserTARGET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_and_expressionContext is an interface to support dynamic dispatch. +type IOpt_and_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AND_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + + // IsOpt_and_expressionContext differentiates from other interfaces. + IsOpt_and_expressionContext() +} + +type Opt_and_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_and_expressionContext() *Opt_and_expressionContext { + var p = new(Opt_and_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_and_expression + return p +} + +func InitEmptyOpt_and_expressionContext(p *Opt_and_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_and_expression +} + +func (*Opt_and_expressionContext) IsOpt_and_expressionContext() {} + +func NewOpt_and_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_and_expressionContext { + var p = new(Opt_and_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_and_expression + + return p +} + +func (s *Opt_and_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_and_expressionContext) AND_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAND_SYMBOL, 0) +} + +func (s *Opt_and_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Opt_and_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_and_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_and_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_and_expression(s) + } +} + +func (s *Opt_and_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_and_expression(s) + } +} + +func (s *Opt_and_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_and_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_and_expression() (localctx IOpt_and_expressionContext) { + localctx = NewOpt_and_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 470, GoogleSQLParserRULE_opt_and_expression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3398) + p.Match(GoogleSQLParserAND_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3399) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStatement_level_hintContext is an interface to support dynamic dispatch. +type IStatement_level_hintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Hint() IHintContext + + // IsStatement_level_hintContext differentiates from other interfaces. + IsStatement_level_hintContext() +} + +type Statement_level_hintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStatement_level_hintContext() *Statement_level_hintContext { + var p = new(Statement_level_hintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_statement_level_hint + return p +} + +func InitEmptyStatement_level_hintContext(p *Statement_level_hintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_statement_level_hint +} + +func (*Statement_level_hintContext) IsStatement_level_hintContext() {} + +func NewStatement_level_hintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Statement_level_hintContext { + var p = new(Statement_level_hintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_statement_level_hint + + return p +} + +func (s *Statement_level_hintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Statement_level_hintContext) Hint() IHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Statement_level_hintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Statement_level_hintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Statement_level_hintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterStatement_level_hint(s) + } +} + +func (s *Statement_level_hintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitStatement_level_hint(s) + } +} + +func (s *Statement_level_hintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitStatement_level_hint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Statement_level_hint() (localctx IStatement_level_hintContext) { + localctx = NewStatement_level_hintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 472, GoogleSQLParserRULE_statement_level_hint) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3401) + p.Hint() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuery_statementContext is an interface to support dynamic dispatch. +type IQuery_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Query() IQueryContext + + // IsQuery_statementContext differentiates from other interfaces. + IsQuery_statementContext() +} + +type Query_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuery_statementContext() *Query_statementContext { + var p = new(Query_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_query_statement + return p +} + +func InitEmptyQuery_statementContext(p *Query_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_query_statement +} + +func (*Query_statementContext) IsQuery_statementContext() {} + +func NewQuery_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_statementContext { + var p = new(Query_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_query_statement + + return p +} + +func (s *Query_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Query_statementContext) Query() IQueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryContext) +} + +func (s *Query_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Query_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Query_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterQuery_statement(s) + } +} + +func (s *Query_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitQuery_statement(s) + } +} + +func (s *Query_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitQuery_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Query_statement() (localctx IQuery_statementContext) { + localctx = NewQuery_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 474, GoogleSQLParserRULE_query_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3403) + p.Query() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDml_statementContext is an interface to support dynamic dispatch. +type IDml_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Insert_statement() IInsert_statementContext + Delete_statement() IDelete_statementContext + Update_statement() IUpdate_statementContext + + // IsDml_statementContext differentiates from other interfaces. + IsDml_statementContext() +} + +type Dml_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDml_statementContext() *Dml_statementContext { + var p = new(Dml_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_dml_statement + return p +} + +func InitEmptyDml_statementContext(p *Dml_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_dml_statement +} + +func (*Dml_statementContext) IsDml_statementContext() {} + +func NewDml_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dml_statementContext { + var p = new(Dml_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_dml_statement + + return p +} + +func (s *Dml_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dml_statementContext) Insert_statement() IInsert_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsert_statementContext) +} + +func (s *Dml_statementContext) Delete_statement() IDelete_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDelete_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDelete_statementContext) +} + +func (s *Dml_statementContext) Update_statement() IUpdate_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_statementContext) +} + +func (s *Dml_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dml_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dml_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterDml_statement(s) + } +} + +func (s *Dml_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitDml_statement(s) + } +} + +func (s *Dml_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitDml_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Dml_statement() (localctx IDml_statementContext) { + localctx = NewDml_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 476, GoogleSQLParserRULE_dml_statement) + p.SetState(3408) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserINSERT_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3405) + p.Insert_statement() + } + + case GoogleSQLParserDELETE_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3406) + p.Delete_statement() + } + + case GoogleSQLParserUPDATE_SYMBOL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3407) + p.Update_statement() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdate_statementContext is an interface to support dynamic dispatch. +type IUpdate_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UPDATE_SYMBOL() antlr.TerminalNode + Maybe_dashed_generalized_path_expression() IMaybe_dashed_generalized_path_expressionContext + SET_SYMBOL() antlr.TerminalNode + Update_item_list() IUpdate_item_listContext + Hint() IHintContext + As_alias() IAs_aliasContext + Opt_with_offset_and_alias() IOpt_with_offset_and_aliasContext + From_clause() IFrom_clauseContext + Opt_where_expression() IOpt_where_expressionContext + Opt_assert_rows_modified() IOpt_assert_rows_modifiedContext + Opt_returning_clause() IOpt_returning_clauseContext + + // IsUpdate_statementContext differentiates from other interfaces. + IsUpdate_statementContext() +} + +type Update_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdate_statementContext() *Update_statementContext { + var p = new(Update_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_update_statement + return p +} + +func InitEmptyUpdate_statementContext(p *Update_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_update_statement +} + +func (*Update_statementContext) IsUpdate_statementContext() {} + +func NewUpdate_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_statementContext { + var p = new(Update_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_update_statement + + return p +} + +func (s *Update_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_statementContext) UPDATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUPDATE_SYMBOL, 0) +} + +func (s *Update_statementContext) Maybe_dashed_generalized_path_expression() IMaybe_dashed_generalized_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_dashed_generalized_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_dashed_generalized_path_expressionContext) +} + +func (s *Update_statementContext) SET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSET_SYMBOL, 0) +} + +func (s *Update_statementContext) Update_item_list() IUpdate_item_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_item_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_item_listContext) +} + +func (s *Update_statementContext) Hint() IHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Update_statementContext) As_alias() IAs_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_aliasContext) +} + +func (s *Update_statementContext) Opt_with_offset_and_alias() IOpt_with_offset_and_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_with_offset_and_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_with_offset_and_aliasContext) +} + +func (s *Update_statementContext) From_clause() IFrom_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrom_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrom_clauseContext) +} + +func (s *Update_statementContext) Opt_where_expression() IOpt_where_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_where_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_where_expressionContext) +} + +func (s *Update_statementContext) Opt_assert_rows_modified() IOpt_assert_rows_modifiedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_assert_rows_modifiedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_assert_rows_modifiedContext) +} + +func (s *Update_statementContext) Opt_returning_clause() IOpt_returning_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_returning_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_returning_clauseContext) +} + +func (s *Update_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterUpdate_statement(s) + } +} + +func (s *Update_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitUpdate_statement(s) + } +} + +func (s *Update_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitUpdate_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Update_statement() (localctx IUpdate_statementContext) { + localctx = NewUpdate_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 478, GoogleSQLParserRULE_update_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3410) + p.Match(GoogleSQLParserUPDATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3411) + p.Maybe_dashed_generalized_path_expression() + } + p.SetState(3413) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(3412) + p.Hint() + } + + } + p.SetState(3416) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-58)) & ^0x3f) == 0 && ((int64(1)<<(_la-58))&-6981105432269881343) != 0) || ((int64((_la-122)) & ^0x3f) == 0 && ((int64(1)<<(_la-122))&-1) != 0) || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&-1) != 0) || ((int64((_la-250)) & ^0x3f) == 0 && ((int64(1)<<(_la-250))&35184372088703) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&33488865) != 0) { + { + p.SetState(3415) + p.As_alias() + } + + } + p.SetState(3419) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWITH_SYMBOL { + { + p.SetState(3418) + p.Opt_with_offset_and_alias() + } + + } + { + p.SetState(3421) + p.Match(GoogleSQLParserSET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3422) + p.Update_item_list() + } + p.SetState(3424) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserFROM_SYMBOL { + { + p.SetState(3423) + p.From_clause() + } + + } + p.SetState(3427) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWHERE_SYMBOL { + { + p.SetState(3426) + p.Opt_where_expression() + } + + } + p.SetState(3430) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserASSERT_ROWS_MODIFIED_SYMBOL { + { + p.SetState(3429) + p.Opt_assert_rows_modified() + } + + } + p.SetState(3433) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserTHEN_SYMBOL { + { + p.SetState(3432) + p.Opt_returning_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDelete_statementContext is an interface to support dynamic dispatch. +type IDelete_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DELETE_SYMBOL() antlr.TerminalNode + Maybe_dashed_generalized_path_expression() IMaybe_dashed_generalized_path_expressionContext + FROM_SYMBOL() antlr.TerminalNode + Hint() IHintContext + As_alias() IAs_aliasContext + Opt_with_offset_and_alias() IOpt_with_offset_and_aliasContext + Opt_where_expression() IOpt_where_expressionContext + Opt_assert_rows_modified() IOpt_assert_rows_modifiedContext + Opt_returning_clause() IOpt_returning_clauseContext + + // IsDelete_statementContext differentiates from other interfaces. + IsDelete_statementContext() +} + +type Delete_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDelete_statementContext() *Delete_statementContext { + var p = new(Delete_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_delete_statement + return p +} + +func InitEmptyDelete_statementContext(p *Delete_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_delete_statement +} + +func (*Delete_statementContext) IsDelete_statementContext() {} + +func NewDelete_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Delete_statementContext { + var p = new(Delete_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_delete_statement + + return p +} + +func (s *Delete_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Delete_statementContext) DELETE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDELETE_SYMBOL, 0) +} + +func (s *Delete_statementContext) Maybe_dashed_generalized_path_expression() IMaybe_dashed_generalized_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_dashed_generalized_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_dashed_generalized_path_expressionContext) +} + +func (s *Delete_statementContext) FROM_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFROM_SYMBOL, 0) +} + +func (s *Delete_statementContext) Hint() IHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Delete_statementContext) As_alias() IAs_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_aliasContext) +} + +func (s *Delete_statementContext) Opt_with_offset_and_alias() IOpt_with_offset_and_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_with_offset_and_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_with_offset_and_aliasContext) +} + +func (s *Delete_statementContext) Opt_where_expression() IOpt_where_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_where_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_where_expressionContext) +} + +func (s *Delete_statementContext) Opt_assert_rows_modified() IOpt_assert_rows_modifiedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_assert_rows_modifiedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_assert_rows_modifiedContext) +} + +func (s *Delete_statementContext) Opt_returning_clause() IOpt_returning_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_returning_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_returning_clauseContext) +} + +func (s *Delete_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Delete_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Delete_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterDelete_statement(s) + } +} + +func (s *Delete_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitDelete_statement(s) + } +} + +func (s *Delete_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitDelete_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Delete_statement() (localctx IDelete_statementContext) { + localctx = NewDelete_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 480, GoogleSQLParserRULE_delete_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3435) + p.Match(GoogleSQLParserDELETE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3437) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserFROM_SYMBOL { + { + p.SetState(3436) + p.Match(GoogleSQLParserFROM_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3439) + p.Maybe_dashed_generalized_path_expression() + } + p.SetState(3441) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(3440) + p.Hint() + } + + } + p.SetState(3444) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-58)) & ^0x3f) == 0 && ((int64(1)<<(_la-58))&-6981105432269881343) != 0) || ((int64((_la-122)) & ^0x3f) == 0 && ((int64(1)<<(_la-122))&-1) != 0) || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&-1) != 0) || ((int64((_la-250)) & ^0x3f) == 0 && ((int64(1)<<(_la-250))&35184372088703) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&33488865) != 0) { + { + p.SetState(3443) + p.As_alias() + } + + } + p.SetState(3447) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWITH_SYMBOL { + { + p.SetState(3446) + p.Opt_with_offset_and_alias() + } + + } + p.SetState(3450) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWHERE_SYMBOL { + { + p.SetState(3449) + p.Opt_where_expression() + } + + } + p.SetState(3453) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserASSERT_ROWS_MODIFIED_SYMBOL { + { + p.SetState(3452) + p.Opt_assert_rows_modified() + } + + } + p.SetState(3456) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserTHEN_SYMBOL { + { + p.SetState(3455) + p.Opt_returning_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInsert_statementContext is an interface to support dynamic dispatch. +type IInsert_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Insert_statement_prefix() IInsert_statement_prefixContext + Insert_values_or_query() IInsert_values_or_queryContext + Column_list() IColumn_listContext + Opt_assert_rows_modified() IOpt_assert_rows_modifiedContext + Opt_returning_clause() IOpt_returning_clauseContext + Insert_values_list_or_table_clause() IInsert_values_list_or_table_clauseContext + On_conflict_clause() IOn_conflict_clauseContext + LR_BRACKET_SYMBOL() antlr.TerminalNode + Query() IQueryContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsInsert_statementContext differentiates from other interfaces. + IsInsert_statementContext() +} + +type Insert_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInsert_statementContext() *Insert_statementContext { + var p = new(Insert_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_insert_statement + return p +} + +func InitEmptyInsert_statementContext(p *Insert_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_insert_statement +} + +func (*Insert_statementContext) IsInsert_statementContext() {} + +func NewInsert_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_statementContext { + var p = new(Insert_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_insert_statement + + return p +} + +func (s *Insert_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Insert_statementContext) Insert_statement_prefix() IInsert_statement_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_statement_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsert_statement_prefixContext) +} + +func (s *Insert_statementContext) Insert_values_or_query() IInsert_values_or_queryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_values_or_queryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsert_values_or_queryContext) +} + +func (s *Insert_statementContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Insert_statementContext) Opt_assert_rows_modified() IOpt_assert_rows_modifiedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_assert_rows_modifiedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_assert_rows_modifiedContext) +} + +func (s *Insert_statementContext) Opt_returning_clause() IOpt_returning_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_returning_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_returning_clauseContext) +} + +func (s *Insert_statementContext) Insert_values_list_or_table_clause() IInsert_values_list_or_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_values_list_or_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsert_values_list_or_table_clauseContext) +} + +func (s *Insert_statementContext) On_conflict_clause() IOn_conflict_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_conflict_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_conflict_clauseContext) +} + +func (s *Insert_statementContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Insert_statementContext) Query() IQueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryContext) +} + +func (s *Insert_statementContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Insert_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Insert_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Insert_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterInsert_statement(s) + } +} + +func (s *Insert_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitInsert_statement(s) + } +} + +func (s *Insert_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitInsert_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Insert_statement() (localctx IInsert_statementContext) { + localctx = NewInsert_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 482, GoogleSQLParserRULE_insert_statement) + var _la int + + p.SetState(3495) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 397, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3458) + p.Insert_statement_prefix() + } + p.SetState(3460) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 388, p.GetParserRuleContext()) == 1 { + { + p.SetState(3459) + p.Column_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3462) + p.Insert_values_or_query() + } + p.SetState(3464) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserASSERT_ROWS_MODIFIED_SYMBOL { + { + p.SetState(3463) + p.Opt_assert_rows_modified() + } + + } + p.SetState(3467) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserTHEN_SYMBOL { + { + p.SetState(3466) + p.Opt_returning_clause() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3469) + p.Insert_statement_prefix() + } + p.SetState(3471) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL { + { + p.SetState(3470) + p.Column_list() + } + + } + { + p.SetState(3473) + p.Insert_values_list_or_table_clause() + } + { + p.SetState(3474) + p.On_conflict_clause() + } + p.SetState(3476) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserASSERT_ROWS_MODIFIED_SYMBOL { + { + p.SetState(3475) + p.Opt_assert_rows_modified() + } + + } + p.SetState(3479) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserTHEN_SYMBOL { + { + p.SetState(3478) + p.Opt_returning_clause() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3481) + p.Insert_statement_prefix() + } + p.SetState(3483) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 394, p.GetParserRuleContext()) == 1 { + { + p.SetState(3482) + p.Column_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3485) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3486) + p.Query() + } + { + p.SetState(3487) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3488) + p.On_conflict_clause() + } + p.SetState(3490) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserASSERT_ROWS_MODIFIED_SYMBOL { + { + p.SetState(3489) + p.Opt_assert_rows_modified() + } + + } + p.SetState(3493) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserTHEN_SYMBOL { + { + p.SetState(3492) + p.Opt_returning_clause() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOn_conflict_clauseContext is an interface to support dynamic dispatch. +type IOn_conflict_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON_SYMBOL() antlr.TerminalNode + CONFLICT_SYMBOL() antlr.TerminalNode + DO_SYMBOL() antlr.TerminalNode + NOTHING_SYMBOL() antlr.TerminalNode + Opt_conflict_target() IOpt_conflict_targetContext + UPDATE_SYMBOL() antlr.TerminalNode + SET_SYMBOL() antlr.TerminalNode + Update_item_list() IUpdate_item_listContext + Opt_where_expression() IOpt_where_expressionContext + + // IsOn_conflict_clauseContext differentiates from other interfaces. + IsOn_conflict_clauseContext() +} + +type On_conflict_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOn_conflict_clauseContext() *On_conflict_clauseContext { + var p = new(On_conflict_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_on_conflict_clause + return p +} + +func InitEmptyOn_conflict_clauseContext(p *On_conflict_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_on_conflict_clause +} + +func (*On_conflict_clauseContext) IsOn_conflict_clauseContext() {} + +func NewOn_conflict_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_conflict_clauseContext { + var p = new(On_conflict_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_on_conflict_clause + + return p +} + +func (s *On_conflict_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_conflict_clauseContext) ON_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserON_SYMBOL, 0) +} + +func (s *On_conflict_clauseContext) CONFLICT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCONFLICT_SYMBOL, 0) +} + +func (s *On_conflict_clauseContext) DO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDO_SYMBOL, 0) +} + +func (s *On_conflict_clauseContext) NOTHING_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNOTHING_SYMBOL, 0) +} + +func (s *On_conflict_clauseContext) Opt_conflict_target() IOpt_conflict_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_conflict_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_conflict_targetContext) +} + +func (s *On_conflict_clauseContext) UPDATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUPDATE_SYMBOL, 0) +} + +func (s *On_conflict_clauseContext) SET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSET_SYMBOL, 0) +} + +func (s *On_conflict_clauseContext) Update_item_list() IUpdate_item_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_item_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_item_listContext) +} + +func (s *On_conflict_clauseContext) Opt_where_expression() IOpt_where_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_where_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_where_expressionContext) +} + +func (s *On_conflict_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_conflict_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_conflict_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOn_conflict_clause(s) + } +} + +func (s *On_conflict_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOn_conflict_clause(s) + } +} + +func (s *On_conflict_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOn_conflict_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) On_conflict_clause() (localctx IOn_conflict_clauseContext) { + localctx = NewOn_conflict_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 484, GoogleSQLParserRULE_on_conflict_clause) + var _la int + + p.SetState(3516) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 401, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3497) + p.Match(GoogleSQLParserON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3498) + p.Match(GoogleSQLParserCONFLICT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3500) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL || _la == GoogleSQLParserON_SYMBOL { + { + p.SetState(3499) + p.Opt_conflict_target() + } + + } + { + p.SetState(3502) + p.Match(GoogleSQLParserDO_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3503) + p.Match(GoogleSQLParserNOTHING_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3504) + p.Match(GoogleSQLParserON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3505) + p.Match(GoogleSQLParserCONFLICT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3507) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL || _la == GoogleSQLParserON_SYMBOL { + { + p.SetState(3506) + p.Opt_conflict_target() + } + + } + { + p.SetState(3509) + p.Match(GoogleSQLParserDO_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3510) + p.Match(GoogleSQLParserUPDATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3511) + p.Match(GoogleSQLParserSET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3512) + p.Update_item_list() + } + p.SetState(3514) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWHERE_SYMBOL { + { + p.SetState(3513) + p.Opt_where_expression() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_where_expressionContext is an interface to support dynamic dispatch. +type IOpt_where_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHERE_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + + // IsOpt_where_expressionContext differentiates from other interfaces. + IsOpt_where_expressionContext() +} + +type Opt_where_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_where_expressionContext() *Opt_where_expressionContext { + var p = new(Opt_where_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_where_expression + return p +} + +func InitEmptyOpt_where_expressionContext(p *Opt_where_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_where_expression +} + +func (*Opt_where_expressionContext) IsOpt_where_expressionContext() {} + +func NewOpt_where_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_where_expressionContext { + var p = new(Opt_where_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_where_expression + + return p +} + +func (s *Opt_where_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_where_expressionContext) WHERE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWHERE_SYMBOL, 0) +} + +func (s *Opt_where_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Opt_where_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_where_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_where_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_where_expression(s) + } +} + +func (s *Opt_where_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_where_expression(s) + } +} + +func (s *Opt_where_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_where_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_where_expression() (localctx IOpt_where_expressionContext) { + localctx = NewOpt_where_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 486, GoogleSQLParserRULE_opt_where_expression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3518) + p.Match(GoogleSQLParserWHERE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3519) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_conflict_targetContext is an interface to support dynamic dispatch. +type IOpt_conflict_targetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_list() IColumn_listContext + ON_SYMBOL() antlr.TerminalNode + UNIQUE_SYMBOL() antlr.TerminalNode + CONSTRAINT_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsOpt_conflict_targetContext differentiates from other interfaces. + IsOpt_conflict_targetContext() +} + +type Opt_conflict_targetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_conflict_targetContext() *Opt_conflict_targetContext { + var p = new(Opt_conflict_targetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_conflict_target + return p +} + +func InitEmptyOpt_conflict_targetContext(p *Opt_conflict_targetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_conflict_target +} + +func (*Opt_conflict_targetContext) IsOpt_conflict_targetContext() {} + +func NewOpt_conflict_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_conflict_targetContext { + var p = new(Opt_conflict_targetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_conflict_target + + return p +} + +func (s *Opt_conflict_targetContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_conflict_targetContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Opt_conflict_targetContext) ON_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserON_SYMBOL, 0) +} + +func (s *Opt_conflict_targetContext) UNIQUE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUNIQUE_SYMBOL, 0) +} + +func (s *Opt_conflict_targetContext) CONSTRAINT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCONSTRAINT_SYMBOL, 0) +} + +func (s *Opt_conflict_targetContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Opt_conflict_targetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_conflict_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_conflict_targetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_conflict_target(s) + } +} + +func (s *Opt_conflict_targetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_conflict_target(s) + } +} + +func (s *Opt_conflict_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_conflict_target(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_conflict_target() (localctx IOpt_conflict_targetContext) { + localctx = NewOpt_conflict_targetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 488, GoogleSQLParserRULE_opt_conflict_target) + p.SetState(3526) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserLR_BRACKET_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3521) + p.Column_list() + } + + case GoogleSQLParserON_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3522) + p.Match(GoogleSQLParserON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3523) + p.Match(GoogleSQLParserUNIQUE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3524) + p.Match(GoogleSQLParserCONSTRAINT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3525) + p.Identifier() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdate_item_listContext is an interface to support dynamic dispatch. +type IUpdate_item_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllUpdate_item() []IUpdate_itemContext + Update_item(i int) IUpdate_itemContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsUpdate_item_listContext differentiates from other interfaces. + IsUpdate_item_listContext() +} + +type Update_item_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdate_item_listContext() *Update_item_listContext { + var p = new(Update_item_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_update_item_list + return p +} + +func InitEmptyUpdate_item_listContext(p *Update_item_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_update_item_list +} + +func (*Update_item_listContext) IsUpdate_item_listContext() {} + +func NewUpdate_item_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_item_listContext { + var p = new(Update_item_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_update_item_list + + return p +} + +func (s *Update_item_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_item_listContext) AllUpdate_item() []IUpdate_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUpdate_itemContext); ok { + len++ + } + } + + tst := make([]IUpdate_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUpdate_itemContext); ok { + tst[i] = t.(IUpdate_itemContext) + i++ + } + } + + return tst +} + +func (s *Update_item_listContext) Update_item(i int) IUpdate_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_itemContext) +} + +func (s *Update_item_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Update_item_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Update_item_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_item_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_item_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterUpdate_item_list(s) + } +} + +func (s *Update_item_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitUpdate_item_list(s) + } +} + +func (s *Update_item_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitUpdate_item_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Update_item_list() (localctx IUpdate_item_listContext) { + localctx = NewUpdate_item_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 490, GoogleSQLParserRULE_update_item_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3528) + p.Update_item() + } + p.SetState(3533) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(3529) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3530) + p.Update_item() + } + + p.SetState(3535) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdate_itemContext is an interface to support dynamic dispatch. +type IUpdate_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Update_set_value() IUpdate_set_valueContext + Nested_dml_statement() INested_dml_statementContext + + // IsUpdate_itemContext differentiates from other interfaces. + IsUpdate_itemContext() +} + +type Update_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdate_itemContext() *Update_itemContext { + var p = new(Update_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_update_item + return p +} + +func InitEmptyUpdate_itemContext(p *Update_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_update_item +} + +func (*Update_itemContext) IsUpdate_itemContext() {} + +func NewUpdate_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_itemContext { + var p = new(Update_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_update_item + + return p +} + +func (s *Update_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_itemContext) Update_set_value() IUpdate_set_valueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_set_valueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_set_valueContext) +} + +func (s *Update_itemContext) Nested_dml_statement() INested_dml_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INested_dml_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INested_dml_statementContext) +} + +func (s *Update_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterUpdate_item(s) + } +} + +func (s *Update_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitUpdate_item(s) + } +} + +func (s *Update_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitUpdate_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Update_item() (localctx IUpdate_itemContext) { + localctx = NewUpdate_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 492, GoogleSQLParserRULE_update_item) + p.SetState(3538) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3536) + p.Update_set_value() + } + + case GoogleSQLParserLR_BRACKET_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3537) + p.Nested_dml_statement() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdate_set_valueContext is an interface to support dynamic dispatch. +type IUpdate_set_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Generalized_path_expression() IGeneralized_path_expressionContext + EQUAL_OPERATOR() antlr.TerminalNode + Expression_or_default() IExpression_or_defaultContext + + // IsUpdate_set_valueContext differentiates from other interfaces. + IsUpdate_set_valueContext() +} + +type Update_set_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdate_set_valueContext() *Update_set_valueContext { + var p = new(Update_set_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_update_set_value + return p +} + +func InitEmptyUpdate_set_valueContext(p *Update_set_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_update_set_value +} + +func (*Update_set_valueContext) IsUpdate_set_valueContext() {} + +func NewUpdate_set_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_set_valueContext { + var p = new(Update_set_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_update_set_value + + return p +} + +func (s *Update_set_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_set_valueContext) Generalized_path_expression() IGeneralized_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneralized_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneralized_path_expressionContext) +} + +func (s *Update_set_valueContext) EQUAL_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEQUAL_OPERATOR, 0) +} + +func (s *Update_set_valueContext) Expression_or_default() IExpression_or_defaultContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_or_defaultContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpression_or_defaultContext) +} + +func (s *Update_set_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_set_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_set_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterUpdate_set_value(s) + } +} + +func (s *Update_set_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitUpdate_set_value(s) + } +} + +func (s *Update_set_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitUpdate_set_value(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Update_set_value() (localctx IUpdate_set_valueContext) { + localctx = NewUpdate_set_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 494, GoogleSQLParserRULE_update_set_value) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3540) + p.generalized_path_expression(0) + } + { + p.SetState(3541) + p.Match(GoogleSQLParserEQUAL_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3542) + p.Expression_or_default() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INested_dml_statementContext is an interface to support dynamic dispatch. +type INested_dml_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + Dml_statement() IDml_statementContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsNested_dml_statementContext differentiates from other interfaces. + IsNested_dml_statementContext() +} + +type Nested_dml_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNested_dml_statementContext() *Nested_dml_statementContext { + var p = new(Nested_dml_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_nested_dml_statement + return p +} + +func InitEmptyNested_dml_statementContext(p *Nested_dml_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_nested_dml_statement +} + +func (*Nested_dml_statementContext) IsNested_dml_statementContext() {} + +func NewNested_dml_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Nested_dml_statementContext { + var p = new(Nested_dml_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_nested_dml_statement + + return p +} + +func (s *Nested_dml_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Nested_dml_statementContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Nested_dml_statementContext) Dml_statement() IDml_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDml_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDml_statementContext) +} + +func (s *Nested_dml_statementContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Nested_dml_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Nested_dml_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Nested_dml_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterNested_dml_statement(s) + } +} + +func (s *Nested_dml_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitNested_dml_statement(s) + } +} + +func (s *Nested_dml_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitNested_dml_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Nested_dml_statement() (localctx INested_dml_statementContext) { + localctx = NewNested_dml_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 496, GoogleSQLParserRULE_nested_dml_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3544) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3545) + p.Dml_statement() + } + { + p.SetState(3546) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInsert_values_list_or_table_clauseContext is an interface to support dynamic dispatch. +type IInsert_values_list_or_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Insert_values_list() IInsert_values_listContext + Table_clause_unreversed() ITable_clause_unreversedContext + + // IsInsert_values_list_or_table_clauseContext differentiates from other interfaces. + IsInsert_values_list_or_table_clauseContext() +} + +type Insert_values_list_or_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInsert_values_list_or_table_clauseContext() *Insert_values_list_or_table_clauseContext { + var p = new(Insert_values_list_or_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_insert_values_list_or_table_clause + return p +} + +func InitEmptyInsert_values_list_or_table_clauseContext(p *Insert_values_list_or_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_insert_values_list_or_table_clause +} + +func (*Insert_values_list_or_table_clauseContext) IsInsert_values_list_or_table_clauseContext() {} + +func NewInsert_values_list_or_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_values_list_or_table_clauseContext { + var p = new(Insert_values_list_or_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_insert_values_list_or_table_clause + + return p +} + +func (s *Insert_values_list_or_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Insert_values_list_or_table_clauseContext) Insert_values_list() IInsert_values_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_values_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsert_values_listContext) +} + +func (s *Insert_values_list_or_table_clauseContext) Table_clause_unreversed() ITable_clause_unreversedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_clause_unreversedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_clause_unreversedContext) +} + +func (s *Insert_values_list_or_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Insert_values_list_or_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Insert_values_list_or_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterInsert_values_list_or_table_clause(s) + } +} + +func (s *Insert_values_list_or_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitInsert_values_list_or_table_clause(s) + } +} + +func (s *Insert_values_list_or_table_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitInsert_values_list_or_table_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Insert_values_list_or_table_clause() (localctx IInsert_values_list_or_table_clauseContext) { + localctx = NewInsert_values_list_or_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 498, GoogleSQLParserRULE_insert_values_list_or_table_clause) + p.SetState(3550) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserVALUES_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3548) + p.Insert_values_list() + } + + case GoogleSQLParserTABLE_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3549) + p.Table_clause_unreversed() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_clause_unreversedContext is an interface to support dynamic dispatch. +type ITable_clause_unreversedContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLE_SYMBOL() antlr.TerminalNode + Table_clause_no_keyword() ITable_clause_no_keywordContext + + // IsTable_clause_unreversedContext differentiates from other interfaces. + IsTable_clause_unreversedContext() +} + +type Table_clause_unreversedContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_clause_unreversedContext() *Table_clause_unreversedContext { + var p = new(Table_clause_unreversedContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_clause_unreversed + return p +} + +func InitEmptyTable_clause_unreversedContext(p *Table_clause_unreversedContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_clause_unreversed +} + +func (*Table_clause_unreversedContext) IsTable_clause_unreversedContext() {} + +func NewTable_clause_unreversedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_clause_unreversedContext { + var p = new(Table_clause_unreversedContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_table_clause_unreversed + + return p +} + +func (s *Table_clause_unreversedContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_clause_unreversedContext) TABLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTABLE_SYMBOL, 0) +} + +func (s *Table_clause_unreversedContext) Table_clause_no_keyword() ITable_clause_no_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_clause_no_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_clause_no_keywordContext) +} + +func (s *Table_clause_unreversedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_clause_unreversedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_clause_unreversedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTable_clause_unreversed(s) + } +} + +func (s *Table_clause_unreversedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTable_clause_unreversed(s) + } +} + +func (s *Table_clause_unreversedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTable_clause_unreversed(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Table_clause_unreversed() (localctx ITable_clause_unreversedContext) { + localctx = NewTable_clause_unreversedContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 500, GoogleSQLParserRULE_table_clause_unreversed) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3552) + p.Match(GoogleSQLParserTABLE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3553) + p.Table_clause_no_keyword() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_clause_no_keywordContext is an interface to support dynamic dispatch. +type ITable_clause_no_keywordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Path_expression() IPath_expressionContext + Where_clause() IWhere_clauseContext + Tvf_with_suffixes() ITvf_with_suffixesContext + + // IsTable_clause_no_keywordContext differentiates from other interfaces. + IsTable_clause_no_keywordContext() +} + +type Table_clause_no_keywordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_clause_no_keywordContext() *Table_clause_no_keywordContext { + var p = new(Table_clause_no_keywordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_clause_no_keyword + return p +} + +func InitEmptyTable_clause_no_keywordContext(p *Table_clause_no_keywordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_clause_no_keyword +} + +func (*Table_clause_no_keywordContext) IsTable_clause_no_keywordContext() {} + +func NewTable_clause_no_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_clause_no_keywordContext { + var p = new(Table_clause_no_keywordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_table_clause_no_keyword + + return p +} + +func (s *Table_clause_no_keywordContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_clause_no_keywordContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Table_clause_no_keywordContext) Where_clause() IWhere_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_clauseContext) +} + +func (s *Table_clause_no_keywordContext) Tvf_with_suffixes() ITvf_with_suffixesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITvf_with_suffixesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITvf_with_suffixesContext) +} + +func (s *Table_clause_no_keywordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_clause_no_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_clause_no_keywordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTable_clause_no_keyword(s) + } +} + +func (s *Table_clause_no_keywordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTable_clause_no_keyword(s) + } +} + +func (s *Table_clause_no_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTable_clause_no_keyword(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Table_clause_no_keyword() (localctx ITable_clause_no_keywordContext) { + localctx = NewTable_clause_no_keywordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 502, GoogleSQLParserRULE_table_clause_no_keyword) + var _la int + + p.SetState(3563) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 408, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3555) + p.Path_expression() + } + p.SetState(3557) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWHERE_SYMBOL { + { + p.SetState(3556) + p.Where_clause() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3559) + p.Tvf_with_suffixes() + } + p.SetState(3561) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWHERE_SYMBOL { + { + p.SetState(3560) + p.Where_clause() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_returning_clauseContext is an interface to support dynamic dispatch. +type IOpt_returning_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + THEN_SYMBOL() antlr.TerminalNode + RETURN_SYMBOL() antlr.TerminalNode + Select_list() ISelect_listContext + WITH_SYMBOL() antlr.TerminalNode + ACTION_SYMBOL() antlr.TerminalNode + AS_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsOpt_returning_clauseContext differentiates from other interfaces. + IsOpt_returning_clauseContext() +} + +type Opt_returning_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_returning_clauseContext() *Opt_returning_clauseContext { + var p = new(Opt_returning_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_returning_clause + return p +} + +func InitEmptyOpt_returning_clauseContext(p *Opt_returning_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_returning_clause +} + +func (*Opt_returning_clauseContext) IsOpt_returning_clauseContext() {} + +func NewOpt_returning_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_returning_clauseContext { + var p = new(Opt_returning_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_returning_clause + + return p +} + +func (s *Opt_returning_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_returning_clauseContext) THEN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTHEN_SYMBOL, 0) +} + +func (s *Opt_returning_clauseContext) RETURN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRETURN_SYMBOL, 0) +} + +func (s *Opt_returning_clauseContext) Select_list() ISelect_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_listContext) +} + +func (s *Opt_returning_clauseContext) WITH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWITH_SYMBOL, 0) +} + +func (s *Opt_returning_clauseContext) ACTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserACTION_SYMBOL, 0) +} + +func (s *Opt_returning_clauseContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Opt_returning_clauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Opt_returning_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_returning_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_returning_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_returning_clause(s) + } +} + +func (s *Opt_returning_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_returning_clause(s) + } +} + +func (s *Opt_returning_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_returning_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_returning_clause() (localctx IOpt_returning_clauseContext) { + localctx = NewOpt_returning_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 504, GoogleSQLParserRULE_opt_returning_clause) + p.SetState(3581) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 409, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3565) + p.Match(GoogleSQLParserTHEN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3566) + p.Match(GoogleSQLParserRETURN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3567) + p.Select_list() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3568) + p.Match(GoogleSQLParserTHEN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3569) + p.Match(GoogleSQLParserRETURN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3570) + p.Match(GoogleSQLParserWITH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3571) + p.Match(GoogleSQLParserACTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3572) + p.Select_list() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3573) + p.Match(GoogleSQLParserTHEN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3574) + p.Match(GoogleSQLParserRETURN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3575) + p.Match(GoogleSQLParserWITH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3576) + p.Match(GoogleSQLParserACTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3577) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3578) + p.Identifier() + } + { + p.SetState(3579) + p.Select_list() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_assert_rows_modifiedContext is an interface to support dynamic dispatch. +type IOpt_assert_rows_modifiedContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ASSERT_ROWS_MODIFIED_SYMBOL() antlr.TerminalNode + Possibly_cast_int_literal_or_parameter() IPossibly_cast_int_literal_or_parameterContext + + // IsOpt_assert_rows_modifiedContext differentiates from other interfaces. + IsOpt_assert_rows_modifiedContext() +} + +type Opt_assert_rows_modifiedContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_assert_rows_modifiedContext() *Opt_assert_rows_modifiedContext { + var p = new(Opt_assert_rows_modifiedContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_assert_rows_modified + return p +} + +func InitEmptyOpt_assert_rows_modifiedContext(p *Opt_assert_rows_modifiedContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_assert_rows_modified +} + +func (*Opt_assert_rows_modifiedContext) IsOpt_assert_rows_modifiedContext() {} + +func NewOpt_assert_rows_modifiedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_assert_rows_modifiedContext { + var p = new(Opt_assert_rows_modifiedContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_assert_rows_modified + + return p +} + +func (s *Opt_assert_rows_modifiedContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_assert_rows_modifiedContext) ASSERT_ROWS_MODIFIED_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserASSERT_ROWS_MODIFIED_SYMBOL, 0) +} + +func (s *Opt_assert_rows_modifiedContext) Possibly_cast_int_literal_or_parameter() IPossibly_cast_int_literal_or_parameterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPossibly_cast_int_literal_or_parameterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPossibly_cast_int_literal_or_parameterContext) +} + +func (s *Opt_assert_rows_modifiedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_assert_rows_modifiedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_assert_rows_modifiedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_assert_rows_modified(s) + } +} + +func (s *Opt_assert_rows_modifiedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_assert_rows_modified(s) + } +} + +func (s *Opt_assert_rows_modifiedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_assert_rows_modified(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_assert_rows_modified() (localctx IOpt_assert_rows_modifiedContext) { + localctx = NewOpt_assert_rows_modifiedContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 506, GoogleSQLParserRULE_opt_assert_rows_modified) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3583) + p.Match(GoogleSQLParserASSERT_ROWS_MODIFIED_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3584) + p.Possibly_cast_int_literal_or_parameter() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInsert_values_or_queryContext is an interface to support dynamic dispatch. +type IInsert_values_or_queryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Insert_values_list() IInsert_values_listContext + Query() IQueryContext + + // IsInsert_values_or_queryContext differentiates from other interfaces. + IsInsert_values_or_queryContext() +} + +type Insert_values_or_queryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInsert_values_or_queryContext() *Insert_values_or_queryContext { + var p = new(Insert_values_or_queryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_insert_values_or_query + return p +} + +func InitEmptyInsert_values_or_queryContext(p *Insert_values_or_queryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_insert_values_or_query +} + +func (*Insert_values_or_queryContext) IsInsert_values_or_queryContext() {} + +func NewInsert_values_or_queryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_values_or_queryContext { + var p = new(Insert_values_or_queryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_insert_values_or_query + + return p +} + +func (s *Insert_values_or_queryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Insert_values_or_queryContext) Insert_values_list() IInsert_values_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_values_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsert_values_listContext) +} + +func (s *Insert_values_or_queryContext) Query() IQueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryContext) +} + +func (s *Insert_values_or_queryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Insert_values_or_queryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Insert_values_or_queryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterInsert_values_or_query(s) + } +} + +func (s *Insert_values_or_queryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitInsert_values_or_query(s) + } +} + +func (s *Insert_values_or_queryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitInsert_values_or_query(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Insert_values_or_query() (localctx IInsert_values_or_queryContext) { + localctx = NewInsert_values_or_queryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 508, GoogleSQLParserRULE_insert_values_or_query) + p.SetState(3588) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserVALUES_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3586) + p.Insert_values_list() + } + + case GoogleSQLParserLR_BRACKET_SYMBOL, GoogleSQLParserFROM_SYMBOL, GoogleSQLParserSELECT_SYMBOL, GoogleSQLParserWITH_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3587) + p.Query() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInsert_values_listContext is an interface to support dynamic dispatch. +type IInsert_values_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VALUES_SYMBOL() antlr.TerminalNode + AllInsert_values_row() []IInsert_values_rowContext + Insert_values_row(i int) IInsert_values_rowContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsInsert_values_listContext differentiates from other interfaces. + IsInsert_values_listContext() +} + +type Insert_values_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInsert_values_listContext() *Insert_values_listContext { + var p = new(Insert_values_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_insert_values_list + return p +} + +func InitEmptyInsert_values_listContext(p *Insert_values_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_insert_values_list +} + +func (*Insert_values_listContext) IsInsert_values_listContext() {} + +func NewInsert_values_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_values_listContext { + var p = new(Insert_values_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_insert_values_list + + return p +} + +func (s *Insert_values_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Insert_values_listContext) VALUES_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserVALUES_SYMBOL, 0) +} + +func (s *Insert_values_listContext) AllInsert_values_row() []IInsert_values_rowContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInsert_values_rowContext); ok { + len++ + } + } + + tst := make([]IInsert_values_rowContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInsert_values_rowContext); ok { + tst[i] = t.(IInsert_values_rowContext) + i++ + } + } + + return tst +} + +func (s *Insert_values_listContext) Insert_values_row(i int) IInsert_values_rowContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_values_rowContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInsert_values_rowContext) +} + +func (s *Insert_values_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Insert_values_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Insert_values_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Insert_values_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Insert_values_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterInsert_values_list(s) + } +} + +func (s *Insert_values_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitInsert_values_list(s) + } +} + +func (s *Insert_values_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitInsert_values_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Insert_values_list() (localctx IInsert_values_listContext) { + localctx = NewInsert_values_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 510, GoogleSQLParserRULE_insert_values_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3590) + p.Match(GoogleSQLParserVALUES_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3591) + p.Insert_values_row() + } + p.SetState(3596) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(3592) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3593) + p.Insert_values_row() + } + + p.SetState(3598) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInsert_values_rowContext is an interface to support dynamic dispatch. +type IInsert_values_rowContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + AllExpression_or_default() []IExpression_or_defaultContext + Expression_or_default(i int) IExpression_or_defaultContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsInsert_values_rowContext differentiates from other interfaces. + IsInsert_values_rowContext() +} + +type Insert_values_rowContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInsert_values_rowContext() *Insert_values_rowContext { + var p = new(Insert_values_rowContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_insert_values_row + return p +} + +func InitEmptyInsert_values_rowContext(p *Insert_values_rowContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_insert_values_row +} + +func (*Insert_values_rowContext) IsInsert_values_rowContext() {} + +func NewInsert_values_rowContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_values_rowContext { + var p = new(Insert_values_rowContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_insert_values_row + + return p +} + +func (s *Insert_values_rowContext) GetParser() antlr.Parser { return s.parser } + +func (s *Insert_values_rowContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Insert_values_rowContext) AllExpression_or_default() []IExpression_or_defaultContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpression_or_defaultContext); ok { + len++ + } + } + + tst := make([]IExpression_or_defaultContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpression_or_defaultContext); ok { + tst[i] = t.(IExpression_or_defaultContext) + i++ + } + } + + return tst +} + +func (s *Insert_values_rowContext) Expression_or_default(i int) IExpression_or_defaultContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_or_defaultContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpression_or_defaultContext) +} + +func (s *Insert_values_rowContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Insert_values_rowContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Insert_values_rowContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Insert_values_rowContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Insert_values_rowContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Insert_values_rowContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterInsert_values_row(s) + } +} + +func (s *Insert_values_rowContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitInsert_values_row(s) + } +} + +func (s *Insert_values_rowContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitInsert_values_row(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Insert_values_row() (localctx IInsert_values_rowContext) { + localctx = NewInsert_values_rowContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 512, GoogleSQLParserRULE_insert_values_row) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3599) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3600) + p.Expression_or_default() + } + p.SetState(3605) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(3601) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3602) + p.Expression_or_default() + } + + p.SetState(3607) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3608) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpression_or_defaultContext is an interface to support dynamic dispatch. +type IExpression_or_defaultContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + DEFAULT_SYMBOL() antlr.TerminalNode + + // IsExpression_or_defaultContext differentiates from other interfaces. + IsExpression_or_defaultContext() +} + +type Expression_or_defaultContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpression_or_defaultContext() *Expression_or_defaultContext { + var p = new(Expression_or_defaultContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_expression_or_default + return p +} + +func InitEmptyExpression_or_defaultContext(p *Expression_or_defaultContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_expression_or_default +} + +func (*Expression_or_defaultContext) IsExpression_or_defaultContext() {} + +func NewExpression_or_defaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expression_or_defaultContext { + var p = new(Expression_or_defaultContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_expression_or_default + + return p +} + +func (s *Expression_or_defaultContext) GetParser() antlr.Parser { return s.parser } + +func (s *Expression_or_defaultContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Expression_or_defaultContext) DEFAULT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDEFAULT_SYMBOL, 0) +} + +func (s *Expression_or_defaultContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Expression_or_defaultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Expression_or_defaultContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterExpression_or_default(s) + } +} + +func (s *Expression_or_defaultContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitExpression_or_default(s) + } +} + +func (s *Expression_or_defaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitExpression_or_default(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Expression_or_default() (localctx IExpression_or_defaultContext) { + localctx = NewExpression_or_defaultContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 514, GoogleSQLParserRULE_expression_or_default) + p.SetState(3612) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserPLUS_OPERATOR, GoogleSQLParserMINUS_OPERATOR, GoogleSQLParserBITWISE_NOT_OPERATOR, GoogleSQLParserRC_BRACKET_SYMBOL, GoogleSQLParserLR_BRACKET_SYMBOL, GoogleSQLParserLS_BRACKET_SYMBOL, GoogleSQLParserQUESTION_SYMBOL, GoogleSQLParserAT_SYMBOL, GoogleSQLParserATAT_SYMBOL, GoogleSQLParserSTRING_LITERAL, GoogleSQLParserBYTES_LITERAL, GoogleSQLParserFLOATING_POINT_LITERAL, GoogleSQLParserINTEGER_LITERAL, GoogleSQLParserARRAY_SYMBOL, GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserLEFT_SYMBOL, GoogleSQLParserNULL_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserRIGHT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSTRUCT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserWITH_SYMBOL, GoogleSQLParserTRUE_SYMBOL, GoogleSQLParserFALSE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserNOT_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserRANGE_SYMBOL, GoogleSQLParserINTERVAL_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserNEW_SYMBOL, GoogleSQLParserCASE_SYMBOL, GoogleSQLParserCAST_SYMBOL, GoogleSQLParserEXTRACT_SYMBOL, GoogleSQLParserCOLLATE_SYMBOL, GoogleSQLParserIF_SYMBOL, GoogleSQLParserGROUPING_SYMBOL, GoogleSQLParserEXISTS_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3610) + p.expression(0) + } + + case GoogleSQLParserDEFAULT_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3611) + p.Match(GoogleSQLParserDEFAULT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInsert_statement_prefixContext is an interface to support dynamic dispatch. +type IInsert_statement_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INSERT_SYMBOL() antlr.TerminalNode + Maybe_dashed_generalized_path_expression() IMaybe_dashed_generalized_path_expressionContext + Opt_or_ignore_replace_update() IOpt_or_ignore_replace_updateContext + Opt_into() IOpt_intoContext + Hint() IHintContext + + // IsInsert_statement_prefixContext differentiates from other interfaces. + IsInsert_statement_prefixContext() +} + +type Insert_statement_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInsert_statement_prefixContext() *Insert_statement_prefixContext { + var p = new(Insert_statement_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_insert_statement_prefix + return p +} + +func InitEmptyInsert_statement_prefixContext(p *Insert_statement_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_insert_statement_prefix +} + +func (*Insert_statement_prefixContext) IsInsert_statement_prefixContext() {} + +func NewInsert_statement_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_statement_prefixContext { + var p = new(Insert_statement_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_insert_statement_prefix + + return p +} + +func (s *Insert_statement_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Insert_statement_prefixContext) INSERT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINSERT_SYMBOL, 0) +} + +func (s *Insert_statement_prefixContext) Maybe_dashed_generalized_path_expression() IMaybe_dashed_generalized_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_dashed_generalized_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_dashed_generalized_path_expressionContext) +} + +func (s *Insert_statement_prefixContext) Opt_or_ignore_replace_update() IOpt_or_ignore_replace_updateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_ignore_replace_updateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_ignore_replace_updateContext) +} + +func (s *Insert_statement_prefixContext) Opt_into() IOpt_intoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_intoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_intoContext) +} + +func (s *Insert_statement_prefixContext) Hint() IHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Insert_statement_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Insert_statement_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Insert_statement_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterInsert_statement_prefix(s) + } +} + +func (s *Insert_statement_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitInsert_statement_prefix(s) + } +} + +func (s *Insert_statement_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitInsert_statement_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Insert_statement_prefix() (localctx IInsert_statement_prefixContext) { + localctx = NewInsert_statement_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 516, GoogleSQLParserRULE_insert_statement_prefix) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3614) + p.Match(GoogleSQLParserINSERT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3616) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 414, p.GetParserRuleContext()) == 1 { + { + p.SetState(3615) + p.Opt_or_ignore_replace_update() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3619) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserINTO_SYMBOL { + { + p.SetState(3618) + p.Opt_into() + } + + } + { + p.SetState(3621) + p.Maybe_dashed_generalized_path_expression() + } + p.SetState(3623) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(3622) + p.Hint() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMaybe_dashed_generalized_path_expressionContext is an interface to support dynamic dispatch. +type IMaybe_dashed_generalized_path_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Generalized_path_expression() IGeneralized_path_expressionContext + Dashed_path_expression() IDashed_path_expressionContext + + // IsMaybe_dashed_generalized_path_expressionContext differentiates from other interfaces. + IsMaybe_dashed_generalized_path_expressionContext() +} + +type Maybe_dashed_generalized_path_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMaybe_dashed_generalized_path_expressionContext() *Maybe_dashed_generalized_path_expressionContext { + var p = new(Maybe_dashed_generalized_path_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_maybe_dashed_generalized_path_expression + return p +} + +func InitEmptyMaybe_dashed_generalized_path_expressionContext(p *Maybe_dashed_generalized_path_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_maybe_dashed_generalized_path_expression +} + +func (*Maybe_dashed_generalized_path_expressionContext) IsMaybe_dashed_generalized_path_expressionContext() { +} + +func NewMaybe_dashed_generalized_path_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Maybe_dashed_generalized_path_expressionContext { + var p = new(Maybe_dashed_generalized_path_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_maybe_dashed_generalized_path_expression + + return p +} + +func (s *Maybe_dashed_generalized_path_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Maybe_dashed_generalized_path_expressionContext) Generalized_path_expression() IGeneralized_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneralized_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneralized_path_expressionContext) +} + +func (s *Maybe_dashed_generalized_path_expressionContext) Dashed_path_expression() IDashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDashed_path_expressionContext) +} + +func (s *Maybe_dashed_generalized_path_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Maybe_dashed_generalized_path_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Maybe_dashed_generalized_path_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterMaybe_dashed_generalized_path_expression(s) + } +} + +func (s *Maybe_dashed_generalized_path_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitMaybe_dashed_generalized_path_expression(s) + } +} + +func (s *Maybe_dashed_generalized_path_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitMaybe_dashed_generalized_path_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Maybe_dashed_generalized_path_expression() (localctx IMaybe_dashed_generalized_path_expressionContext) { + localctx = NewMaybe_dashed_generalized_path_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 518, GoogleSQLParserRULE_maybe_dashed_generalized_path_expression) + p.SetState(3627) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 417, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3625) + p.generalized_path_expression(0) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3626) + p.dashed_path_expression(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_intoContext is an interface to support dynamic dispatch. +type IOpt_intoContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INTO_SYMBOL() antlr.TerminalNode + + // IsOpt_intoContext differentiates from other interfaces. + IsOpt_intoContext() +} + +type Opt_intoContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_intoContext() *Opt_intoContext { + var p = new(Opt_intoContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_into + return p +} + +func InitEmptyOpt_intoContext(p *Opt_intoContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_into +} + +func (*Opt_intoContext) IsOpt_intoContext() {} + +func NewOpt_intoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_intoContext { + var p = new(Opt_intoContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_into + + return p +} + +func (s *Opt_intoContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_intoContext) INTO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINTO_SYMBOL, 0) +} + +func (s *Opt_intoContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_intoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_intoContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_into(s) + } +} + +func (s *Opt_intoContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_into(s) + } +} + +func (s *Opt_intoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_into(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_into() (localctx IOpt_intoContext) { + localctx = NewOpt_intoContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 520, GoogleSQLParserRULE_opt_into) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3629) + p.Match(GoogleSQLParserINTO_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_or_ignore_replace_updateContext is an interface to support dynamic dispatch. +type IOpt_or_ignore_replace_updateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OR_SYMBOL() antlr.TerminalNode + IGNORE_SYMBOL() antlr.TerminalNode + REPLACE_SYMBOL() antlr.TerminalNode + UPDATE_SYMBOL() antlr.TerminalNode + + // IsOpt_or_ignore_replace_updateContext differentiates from other interfaces. + IsOpt_or_ignore_replace_updateContext() +} + +type Opt_or_ignore_replace_updateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_or_ignore_replace_updateContext() *Opt_or_ignore_replace_updateContext { + var p = new(Opt_or_ignore_replace_updateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_or_ignore_replace_update + return p +} + +func InitEmptyOpt_or_ignore_replace_updateContext(p *Opt_or_ignore_replace_updateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_or_ignore_replace_update +} + +func (*Opt_or_ignore_replace_updateContext) IsOpt_or_ignore_replace_updateContext() {} + +func NewOpt_or_ignore_replace_updateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_or_ignore_replace_updateContext { + var p = new(Opt_or_ignore_replace_updateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_or_ignore_replace_update + + return p +} + +func (s *Opt_or_ignore_replace_updateContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_or_ignore_replace_updateContext) OR_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOR_SYMBOL, 0) +} + +func (s *Opt_or_ignore_replace_updateContext) IGNORE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIGNORE_SYMBOL, 0) +} + +func (s *Opt_or_ignore_replace_updateContext) REPLACE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREPLACE_SYMBOL, 0) +} + +func (s *Opt_or_ignore_replace_updateContext) UPDATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUPDATE_SYMBOL, 0) +} + +func (s *Opt_or_ignore_replace_updateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_or_ignore_replace_updateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_or_ignore_replace_updateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_or_ignore_replace_update(s) + } +} + +func (s *Opt_or_ignore_replace_updateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_or_ignore_replace_update(s) + } +} + +func (s *Opt_or_ignore_replace_updateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_or_ignore_replace_update(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_or_ignore_replace_update() (localctx IOpt_or_ignore_replace_updateContext) { + localctx = NewOpt_or_ignore_replace_updateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 522, GoogleSQLParserRULE_opt_or_ignore_replace_update) + p.SetState(3640) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 418, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3631) + p.Match(GoogleSQLParserOR_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3632) + p.Match(GoogleSQLParserIGNORE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3633) + p.Match(GoogleSQLParserIGNORE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3634) + p.Match(GoogleSQLParserOR_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3635) + p.Match(GoogleSQLParserREPLACE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3636) + p.Match(GoogleSQLParserREPLACE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3637) + p.Match(GoogleSQLParserOR_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3638) + p.Match(GoogleSQLParserUPDATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3639) + p.Match(GoogleSQLParserUPDATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_statementContext is an interface to support dynamic dispatch. +type IAlter_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER_SYMBOL() antlr.TerminalNode + Table_or_table_function() ITable_or_table_functionContext + Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext + Alter_action_list() IAlter_action_listContext + Opt_if_exists() IOpt_if_existsContext + Schema_object_kind() ISchema_object_kindContext + Path_expression() IPath_expressionContext + Generic_entity_type() IGeneric_entity_typeContext + PRIVILEGE_SYMBOL() antlr.TerminalNode + RESTRICTION_SYMBOL() antlr.TerminalNode + AllON_SYMBOL() []antlr.TerminalNode + ON_SYMBOL(i int) antlr.TerminalNode + Privilege_list() IPrivilege_listContext + Identifier() IIdentifierContext + ROW_SYMBOL() antlr.TerminalNode + ACCESS_SYMBOL() antlr.TerminalNode + POLICY_SYMBOL() antlr.TerminalNode + Row_access_policy_alter_action_list() IRow_access_policy_alter_action_listContext + ALL_SYMBOL() antlr.TerminalNode + POLICIES_SYMBOL() antlr.TerminalNode + Row_access_policy_alter_action() IRow_access_policy_alter_actionContext + + // IsAlter_statementContext differentiates from other interfaces. + IsAlter_statementContext() +} + +type Alter_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_statementContext() *Alter_statementContext { + var p = new(Alter_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_alter_statement + return p +} + +func InitEmptyAlter_statementContext(p *Alter_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_alter_statement +} + +func (*Alter_statementContext) IsAlter_statementContext() {} + +func NewAlter_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_statementContext { + var p = new(Alter_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_alter_statement + + return p +} + +func (s *Alter_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_statementContext) ALTER_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserALTER_SYMBOL, 0) +} + +func (s *Alter_statementContext) Table_or_table_function() ITable_or_table_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_or_table_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_or_table_functionContext) +} + +func (s *Alter_statementContext) Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_dashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_dashed_path_expressionContext) +} + +func (s *Alter_statementContext) Alter_action_list() IAlter_action_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_action_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_action_listContext) +} + +func (s *Alter_statementContext) Opt_if_exists() IOpt_if_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_existsContext) +} + +func (s *Alter_statementContext) Schema_object_kind() ISchema_object_kindContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_object_kindContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_object_kindContext) +} + +func (s *Alter_statementContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Alter_statementContext) Generic_entity_type() IGeneric_entity_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneric_entity_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneric_entity_typeContext) +} + +func (s *Alter_statementContext) PRIVILEGE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPRIVILEGE_SYMBOL, 0) +} + +func (s *Alter_statementContext) RESTRICTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRESTRICTION_SYMBOL, 0) +} + +func (s *Alter_statementContext) AllON_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserON_SYMBOL) +} + +func (s *Alter_statementContext) ON_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserON_SYMBOL, i) +} + +func (s *Alter_statementContext) Privilege_list() IPrivilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrivilege_listContext) +} + +func (s *Alter_statementContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Alter_statementContext) ROW_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserROW_SYMBOL, 0) +} + +func (s *Alter_statementContext) ACCESS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserACCESS_SYMBOL, 0) +} + +func (s *Alter_statementContext) POLICY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPOLICY_SYMBOL, 0) +} + +func (s *Alter_statementContext) Row_access_policy_alter_action_list() IRow_access_policy_alter_action_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRow_access_policy_alter_action_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRow_access_policy_alter_action_listContext) +} + +func (s *Alter_statementContext) ALL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserALL_SYMBOL, 0) +} + +func (s *Alter_statementContext) POLICIES_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPOLICIES_SYMBOL, 0) +} + +func (s *Alter_statementContext) Row_access_policy_alter_action() IRow_access_policy_alter_actionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRow_access_policy_alter_actionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRow_access_policy_alter_actionContext) +} + +func (s *Alter_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterAlter_statement(s) + } +} + +func (s *Alter_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitAlter_statement(s) + } +} + +func (s *Alter_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitAlter_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Alter_statement() (localctx IAlter_statementContext) { + localctx = NewAlter_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 524, GoogleSQLParserRULE_alter_statement) + var _la int + + p.SetState(3706) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 425, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3642) + p.Match(GoogleSQLParserALTER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3643) + p.Table_or_table_function() + } + p.SetState(3645) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(3644) + p.Opt_if_exists() + } + + } + { + p.SetState(3647) + p.Maybe_dashed_path_expression() + } + { + p.SetState(3648) + p.Alter_action_list() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3650) + p.Match(GoogleSQLParserALTER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3651) + p.Schema_object_kind() + } + p.SetState(3653) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(3652) + p.Opt_if_exists() + } + + } + { + p.SetState(3655) + p.Path_expression() + } + { + p.SetState(3656) + p.Alter_action_list() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3658) + p.Match(GoogleSQLParserALTER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3659) + p.Generic_entity_type() + } + p.SetState(3661) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(3660) + p.Opt_if_exists() + } + + } + { + p.SetState(3663) + p.Path_expression() + } + { + p.SetState(3664) + p.Alter_action_list() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3666) + p.Match(GoogleSQLParserALTER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3667) + p.Generic_entity_type() + } + p.SetState(3669) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(3668) + p.Opt_if_exists() + } + + } + { + p.SetState(3671) + p.Alter_action_list() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3673) + p.Match(GoogleSQLParserALTER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3674) + p.Match(GoogleSQLParserPRIVILEGE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3675) + p.Match(GoogleSQLParserRESTRICTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3677) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(3676) + p.Opt_if_exists() + } + + } + { + p.SetState(3679) + p.Match(GoogleSQLParserON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3680) + p.Privilege_list() + } + { + p.SetState(3681) + p.Match(GoogleSQLParserON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3682) + p.Identifier() + } + { + p.SetState(3683) + p.Path_expression() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3685) + p.Match(GoogleSQLParserALTER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3686) + p.Match(GoogleSQLParserROW_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3687) + p.Match(GoogleSQLParserACCESS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3688) + p.Match(GoogleSQLParserPOLICY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3690) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(3689) + p.Opt_if_exists() + } + + } + { + p.SetState(3692) + p.Identifier() + } + { + p.SetState(3693) + p.Match(GoogleSQLParserON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3694) + p.Path_expression() + } + { + p.SetState(3695) + p.Row_access_policy_alter_action_list() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(3697) + p.Match(GoogleSQLParserALTER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3698) + p.Match(GoogleSQLParserALL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3699) + p.Match(GoogleSQLParserROW_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3700) + p.Match(GoogleSQLParserACCESS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3701) + p.Match(GoogleSQLParserPOLICIES_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3702) + p.Match(GoogleSQLParserON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3703) + p.Path_expression() + } + { + p.SetState(3704) + p.Row_access_policy_alter_action() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAnalyze_statementContext is an interface to support dynamic dispatch. +type IAnalyze_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ANALYZE_SYMBOL() antlr.TerminalNode + Opt_options_list() IOpt_options_listContext + Table_and_column_info_list() ITable_and_column_info_listContext + + // IsAnalyze_statementContext differentiates from other interfaces. + IsAnalyze_statementContext() +} + +type Analyze_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAnalyze_statementContext() *Analyze_statementContext { + var p = new(Analyze_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_analyze_statement + return p +} + +func InitEmptyAnalyze_statementContext(p *Analyze_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_analyze_statement +} + +func (*Analyze_statementContext) IsAnalyze_statementContext() {} + +func NewAnalyze_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Analyze_statementContext { + var p = new(Analyze_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_analyze_statement + + return p +} + +func (s *Analyze_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Analyze_statementContext) ANALYZE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserANALYZE_SYMBOL, 0) +} + +func (s *Analyze_statementContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Analyze_statementContext) Table_and_column_info_list() ITable_and_column_info_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_and_column_info_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_and_column_info_listContext) +} + +func (s *Analyze_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Analyze_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Analyze_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterAnalyze_statement(s) + } +} + +func (s *Analyze_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitAnalyze_statement(s) + } +} + +func (s *Analyze_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitAnalyze_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Analyze_statement() (localctx IAnalyze_statementContext) { + localctx = NewAnalyze_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 526, GoogleSQLParserRULE_analyze_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3708) + p.Match(GoogleSQLParserANALYZE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3710) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 426, p.GetParserRuleContext()) == 1 { + { + p.SetState(3709) + p.Opt_options_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3713) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-74)) & ^0x3f) == 0 && ((int64(1)<<(_la-74))&-106523215214079) != 0) || ((int64((_la-138)) & ^0x3f) == 0 && ((int64(1)<<(_la-138))&-1) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-36028797018963969) != 0) || ((int64((_la-266)) & ^0x3f) == 0 && ((int64(1)<<(_la-266))&536870911) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&33488865) != 0) { + { + p.SetState(3712) + p.Table_and_column_info_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAssert_statementContext is an interface to support dynamic dispatch. +type IAssert_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ASSERT_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + Opt_description() IOpt_descriptionContext + + // IsAssert_statementContext differentiates from other interfaces. + IsAssert_statementContext() +} + +type Assert_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAssert_statementContext() *Assert_statementContext { + var p = new(Assert_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_assert_statement + return p +} + +func InitEmptyAssert_statementContext(p *Assert_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_assert_statement +} + +func (*Assert_statementContext) IsAssert_statementContext() {} + +func NewAssert_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Assert_statementContext { + var p = new(Assert_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_assert_statement + + return p +} + +func (s *Assert_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Assert_statementContext) ASSERT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserASSERT_SYMBOL, 0) +} + +func (s *Assert_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Assert_statementContext) Opt_description() IOpt_descriptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_descriptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_descriptionContext) +} + +func (s *Assert_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Assert_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Assert_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterAssert_statement(s) + } +} + +func (s *Assert_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitAssert_statement(s) + } +} + +func (s *Assert_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitAssert_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Assert_statement() (localctx IAssert_statementContext) { + localctx = NewAssert_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 528, GoogleSQLParserRULE_assert_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3715) + p.Match(GoogleSQLParserASSERT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3716) + p.expression(0) + } + p.SetState(3718) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(3717) + p.Opt_description() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAux_load_data_statementContext is an interface to support dynamic dispatch. +type IAux_load_data_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOAD_SYMBOL() antlr.TerminalNode + DATA_SYMBOL() antlr.TerminalNode + Append_or_overwrite() IAppend_or_overwriteContext + Maybe_dashed_path_expression_with_scope() IMaybe_dashed_path_expression_with_scopeContext + Aux_load_data_from_files_options_list() IAux_load_data_from_files_options_listContext + Table_element_list() ITable_element_listContext + Load_data_partitions_clause() ILoad_data_partitions_clauseContext + Collate_clause() ICollate_clauseContext + Partition_by_clause_prefix_no_hint() IPartition_by_clause_prefix_no_hintContext + Cluster_by_clause_prefix_no_hint() ICluster_by_clause_prefix_no_hintContext + Opt_options_list() IOpt_options_listContext + Opt_external_table_with_clauses() IOpt_external_table_with_clausesContext + + // IsAux_load_data_statementContext differentiates from other interfaces. + IsAux_load_data_statementContext() +} + +type Aux_load_data_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAux_load_data_statementContext() *Aux_load_data_statementContext { + var p = new(Aux_load_data_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_aux_load_data_statement + return p +} + +func InitEmptyAux_load_data_statementContext(p *Aux_load_data_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_aux_load_data_statement +} + +func (*Aux_load_data_statementContext) IsAux_load_data_statementContext() {} + +func NewAux_load_data_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aux_load_data_statementContext { + var p = new(Aux_load_data_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_aux_load_data_statement + + return p +} + +func (s *Aux_load_data_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Aux_load_data_statementContext) LOAD_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLOAD_SYMBOL, 0) +} + +func (s *Aux_load_data_statementContext) DATA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDATA_SYMBOL, 0) +} + +func (s *Aux_load_data_statementContext) Append_or_overwrite() IAppend_or_overwriteContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAppend_or_overwriteContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAppend_or_overwriteContext) +} + +func (s *Aux_load_data_statementContext) Maybe_dashed_path_expression_with_scope() IMaybe_dashed_path_expression_with_scopeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_dashed_path_expression_with_scopeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_dashed_path_expression_with_scopeContext) +} + +func (s *Aux_load_data_statementContext) Aux_load_data_from_files_options_list() IAux_load_data_from_files_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAux_load_data_from_files_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAux_load_data_from_files_options_listContext) +} + +func (s *Aux_load_data_statementContext) Table_element_list() ITable_element_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_element_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_element_listContext) +} + +func (s *Aux_load_data_statementContext) Load_data_partitions_clause() ILoad_data_partitions_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILoad_data_partitions_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILoad_data_partitions_clauseContext) +} + +func (s *Aux_load_data_statementContext) Collate_clause() ICollate_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollate_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollate_clauseContext) +} + +func (s *Aux_load_data_statementContext) Partition_by_clause_prefix_no_hint() IPartition_by_clause_prefix_no_hintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_by_clause_prefix_no_hintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_by_clause_prefix_no_hintContext) +} + +func (s *Aux_load_data_statementContext) Cluster_by_clause_prefix_no_hint() ICluster_by_clause_prefix_no_hintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_by_clause_prefix_no_hintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_by_clause_prefix_no_hintContext) +} + +func (s *Aux_load_data_statementContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Aux_load_data_statementContext) Opt_external_table_with_clauses() IOpt_external_table_with_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_external_table_with_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_external_table_with_clausesContext) +} + +func (s *Aux_load_data_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Aux_load_data_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Aux_load_data_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterAux_load_data_statement(s) + } +} + +func (s *Aux_load_data_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitAux_load_data_statement(s) + } +} + +func (s *Aux_load_data_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitAux_load_data_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Aux_load_data_statement() (localctx IAux_load_data_statementContext) { + localctx = NewAux_load_data_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 530, GoogleSQLParserRULE_aux_load_data_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3720) + p.Match(GoogleSQLParserLOAD_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3721) + p.Match(GoogleSQLParserDATA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3722) + p.Append_or_overwrite() + } + { + p.SetState(3723) + p.Maybe_dashed_path_expression_with_scope() + } + p.SetState(3725) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL { + { + p.SetState(3724) + p.Table_element_list() + } + + } + p.SetState(3728) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOVERWRITE_SYMBOL || _la == GoogleSQLParserPARTITIONS_SYMBOL { + { + p.SetState(3727) + p.Load_data_partitions_clause() + } + + } + p.SetState(3731) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCOLLATE_SYMBOL { + { + p.SetState(3730) + p.Collate_clause() + } + + } + p.SetState(3734) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserPARTITION_SYMBOL { + { + p.SetState(3733) + p.Partition_by_clause_prefix_no_hint() + } + + } + p.SetState(3737) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCLUSTER_SYMBOL { + { + p.SetState(3736) + p.Cluster_by_clause_prefix_no_hint() + } + + } + p.SetState(3740) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(3739) + p.Opt_options_list() + } + + } + { + p.SetState(3742) + p.Aux_load_data_from_files_options_list() + } + p.SetState(3744) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWITH_SYMBOL { + { + p.SetState(3743) + p.Opt_external_table_with_clauses() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClone_data_statementContext is an interface to support dynamic dispatch. +type IClone_data_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CLONE_SYMBOL() antlr.TerminalNode + DATA_SYMBOL() antlr.TerminalNode + INTO_SYMBOL() antlr.TerminalNode + Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext + FROM_SYMBOL() antlr.TerminalNode + Clone_data_source_list() IClone_data_source_listContext + + // IsClone_data_statementContext differentiates from other interfaces. + IsClone_data_statementContext() +} + +type Clone_data_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClone_data_statementContext() *Clone_data_statementContext { + var p = new(Clone_data_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_clone_data_statement + return p +} + +func InitEmptyClone_data_statementContext(p *Clone_data_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_clone_data_statement +} + +func (*Clone_data_statementContext) IsClone_data_statementContext() {} + +func NewClone_data_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Clone_data_statementContext { + var p = new(Clone_data_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_clone_data_statement + + return p +} + +func (s *Clone_data_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Clone_data_statementContext) CLONE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCLONE_SYMBOL, 0) +} + +func (s *Clone_data_statementContext) DATA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDATA_SYMBOL, 0) +} + +func (s *Clone_data_statementContext) INTO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINTO_SYMBOL, 0) +} + +func (s *Clone_data_statementContext) Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_dashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_dashed_path_expressionContext) +} + +func (s *Clone_data_statementContext) FROM_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFROM_SYMBOL, 0) +} + +func (s *Clone_data_statementContext) Clone_data_source_list() IClone_data_source_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClone_data_source_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClone_data_source_listContext) +} + +func (s *Clone_data_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Clone_data_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Clone_data_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterClone_data_statement(s) + } +} + +func (s *Clone_data_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitClone_data_statement(s) + } +} + +func (s *Clone_data_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitClone_data_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Clone_data_statement() (localctx IClone_data_statementContext) { + localctx = NewClone_data_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 532, GoogleSQLParserRULE_clone_data_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3746) + p.Match(GoogleSQLParserCLONE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3747) + p.Match(GoogleSQLParserDATA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3748) + p.Match(GoogleSQLParserINTO_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3749) + p.Maybe_dashed_path_expression() + } + { + p.SetState(3750) + p.Match(GoogleSQLParserFROM_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3751) + p.Clone_data_source_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClone_data_source_listContext is an interface to support dynamic dispatch. +type IClone_data_source_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllClone_data_source() []IClone_data_sourceContext + Clone_data_source(i int) IClone_data_sourceContext + AllUNION_SYMBOL() []antlr.TerminalNode + UNION_SYMBOL(i int) antlr.TerminalNode + AllALL_SYMBOL() []antlr.TerminalNode + ALL_SYMBOL(i int) antlr.TerminalNode + + // IsClone_data_source_listContext differentiates from other interfaces. + IsClone_data_source_listContext() +} + +type Clone_data_source_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClone_data_source_listContext() *Clone_data_source_listContext { + var p = new(Clone_data_source_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_clone_data_source_list + return p +} + +func InitEmptyClone_data_source_listContext(p *Clone_data_source_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_clone_data_source_list +} + +func (*Clone_data_source_listContext) IsClone_data_source_listContext() {} + +func NewClone_data_source_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Clone_data_source_listContext { + var p = new(Clone_data_source_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_clone_data_source_list + + return p +} + +func (s *Clone_data_source_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Clone_data_source_listContext) AllClone_data_source() []IClone_data_sourceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IClone_data_sourceContext); ok { + len++ + } + } + + tst := make([]IClone_data_sourceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IClone_data_sourceContext); ok { + tst[i] = t.(IClone_data_sourceContext) + i++ + } + } + + return tst +} + +func (s *Clone_data_source_listContext) Clone_data_source(i int) IClone_data_sourceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClone_data_sourceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IClone_data_sourceContext) +} + +func (s *Clone_data_source_listContext) AllUNION_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserUNION_SYMBOL) +} + +func (s *Clone_data_source_listContext) UNION_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUNION_SYMBOL, i) +} + +func (s *Clone_data_source_listContext) AllALL_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserALL_SYMBOL) +} + +func (s *Clone_data_source_listContext) ALL_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserALL_SYMBOL, i) +} + +func (s *Clone_data_source_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Clone_data_source_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Clone_data_source_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterClone_data_source_list(s) + } +} + +func (s *Clone_data_source_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitClone_data_source_list(s) + } +} + +func (s *Clone_data_source_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitClone_data_source_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Clone_data_source_list() (localctx IClone_data_source_listContext) { + localctx = NewClone_data_source_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 534, GoogleSQLParserRULE_clone_data_source_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3753) + p.Clone_data_source() + } + p.SetState(3759) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserUNION_SYMBOL { + { + p.SetState(3754) + p.Match(GoogleSQLParserUNION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3755) + p.Match(GoogleSQLParserALL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3756) + p.Clone_data_source() + } + + p.SetState(3761) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClone_data_sourceContext is an interface to support dynamic dispatch. +type IClone_data_sourceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext + Opt_at_system_time() IOpt_at_system_timeContext + Where_clause() IWhere_clauseContext + + // IsClone_data_sourceContext differentiates from other interfaces. + IsClone_data_sourceContext() +} + +type Clone_data_sourceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClone_data_sourceContext() *Clone_data_sourceContext { + var p = new(Clone_data_sourceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_clone_data_source + return p +} + +func InitEmptyClone_data_sourceContext(p *Clone_data_sourceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_clone_data_source +} + +func (*Clone_data_sourceContext) IsClone_data_sourceContext() {} + +func NewClone_data_sourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Clone_data_sourceContext { + var p = new(Clone_data_sourceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_clone_data_source + + return p +} + +func (s *Clone_data_sourceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Clone_data_sourceContext) Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_dashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_dashed_path_expressionContext) +} + +func (s *Clone_data_sourceContext) Opt_at_system_time() IOpt_at_system_timeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_at_system_timeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_at_system_timeContext) +} + +func (s *Clone_data_sourceContext) Where_clause() IWhere_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_clauseContext) +} + +func (s *Clone_data_sourceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Clone_data_sourceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Clone_data_sourceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterClone_data_source(s) + } +} + +func (s *Clone_data_sourceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitClone_data_source(s) + } +} + +func (s *Clone_data_sourceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitClone_data_source(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Clone_data_source() (localctx IClone_data_sourceContext) { + localctx = NewClone_data_sourceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 536, GoogleSQLParserRULE_clone_data_source) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3762) + p.Maybe_dashed_path_expression() + } + p.SetState(3764) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserFOR_SYMBOL { + { + p.SetState(3763) + p.Opt_at_system_time() + } + + } + p.SetState(3767) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWHERE_SYMBOL { + { + p.SetState(3766) + p.Where_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_external_table_with_clausesContext is an interface to support dynamic dispatch. +type IOpt_external_table_with_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + With_partition_columns_clause() IWith_partition_columns_clauseContext + With_connection_clause() IWith_connection_clauseContext + + // IsOpt_external_table_with_clausesContext differentiates from other interfaces. + IsOpt_external_table_with_clausesContext() +} + +type Opt_external_table_with_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_external_table_with_clausesContext() *Opt_external_table_with_clausesContext { + var p = new(Opt_external_table_with_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_external_table_with_clauses + return p +} + +func InitEmptyOpt_external_table_with_clausesContext(p *Opt_external_table_with_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_external_table_with_clauses +} + +func (*Opt_external_table_with_clausesContext) IsOpt_external_table_with_clausesContext() {} + +func NewOpt_external_table_with_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_external_table_with_clausesContext { + var p = new(Opt_external_table_with_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_external_table_with_clauses + + return p +} + +func (s *Opt_external_table_with_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_external_table_with_clausesContext) With_partition_columns_clause() IWith_partition_columns_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_partition_columns_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_partition_columns_clauseContext) +} + +func (s *Opt_external_table_with_clausesContext) With_connection_clause() IWith_connection_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_connection_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_connection_clauseContext) +} + +func (s *Opt_external_table_with_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_external_table_with_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_external_table_with_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_external_table_with_clauses(s) + } +} + +func (s *Opt_external_table_with_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_external_table_with_clauses(s) + } +} + +func (s *Opt_external_table_with_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_external_table_with_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_external_table_with_clauses() (localctx IOpt_external_table_with_clausesContext) { + localctx = NewOpt_external_table_with_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 538, GoogleSQLParserRULE_opt_external_table_with_clauses) + p.SetState(3774) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 439, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3769) + p.With_partition_columns_clause() + } + { + p.SetState(3770) + p.With_connection_clause() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3772) + p.With_partition_columns_clause() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3773) + p.With_connection_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWith_partition_columns_clauseContext is an interface to support dynamic dispatch. +type IWith_partition_columns_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH_SYMBOL() antlr.TerminalNode + PARTITION_SYMBOL() antlr.TerminalNode + COLUMNS_SYMBOL() antlr.TerminalNode + Table_element_list() ITable_element_listContext + + // IsWith_partition_columns_clauseContext differentiates from other interfaces. + IsWith_partition_columns_clauseContext() +} + +type With_partition_columns_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWith_partition_columns_clauseContext() *With_partition_columns_clauseContext { + var p = new(With_partition_columns_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_with_partition_columns_clause + return p +} + +func InitEmptyWith_partition_columns_clauseContext(p *With_partition_columns_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_with_partition_columns_clause +} + +func (*With_partition_columns_clauseContext) IsWith_partition_columns_clauseContext() {} + +func NewWith_partition_columns_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_partition_columns_clauseContext { + var p = new(With_partition_columns_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_with_partition_columns_clause + + return p +} + +func (s *With_partition_columns_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *With_partition_columns_clauseContext) WITH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWITH_SYMBOL, 0) +} + +func (s *With_partition_columns_clauseContext) PARTITION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPARTITION_SYMBOL, 0) +} + +func (s *With_partition_columns_clauseContext) COLUMNS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOLUMNS_SYMBOL, 0) +} + +func (s *With_partition_columns_clauseContext) Table_element_list() ITable_element_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_element_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_element_listContext) +} + +func (s *With_partition_columns_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *With_partition_columns_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *With_partition_columns_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterWith_partition_columns_clause(s) + } +} + +func (s *With_partition_columns_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitWith_partition_columns_clause(s) + } +} + +func (s *With_partition_columns_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitWith_partition_columns_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) With_partition_columns_clause() (localctx IWith_partition_columns_clauseContext) { + localctx = NewWith_partition_columns_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 540, GoogleSQLParserRULE_with_partition_columns_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3776) + p.Match(GoogleSQLParserWITH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3777) + p.Match(GoogleSQLParserPARTITION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3778) + p.Match(GoogleSQLParserCOLUMNS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3780) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL { + { + p.SetState(3779) + p.Table_element_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAux_load_data_from_files_options_listContext is an interface to support dynamic dispatch. +type IAux_load_data_from_files_options_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM_SYMBOL() antlr.TerminalNode + FILES_SYMBOL() antlr.TerminalNode + Options_list() IOptions_listContext + + // IsAux_load_data_from_files_options_listContext differentiates from other interfaces. + IsAux_load_data_from_files_options_listContext() +} + +type Aux_load_data_from_files_options_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAux_load_data_from_files_options_listContext() *Aux_load_data_from_files_options_listContext { + var p = new(Aux_load_data_from_files_options_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_aux_load_data_from_files_options_list + return p +} + +func InitEmptyAux_load_data_from_files_options_listContext(p *Aux_load_data_from_files_options_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_aux_load_data_from_files_options_list +} + +func (*Aux_load_data_from_files_options_listContext) IsAux_load_data_from_files_options_listContext() { +} + +func NewAux_load_data_from_files_options_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aux_load_data_from_files_options_listContext { + var p = new(Aux_load_data_from_files_options_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_aux_load_data_from_files_options_list + + return p +} + +func (s *Aux_load_data_from_files_options_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Aux_load_data_from_files_options_listContext) FROM_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFROM_SYMBOL, 0) +} + +func (s *Aux_load_data_from_files_options_listContext) FILES_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFILES_SYMBOL, 0) +} + +func (s *Aux_load_data_from_files_options_listContext) Options_list() IOptions_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptions_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptions_listContext) +} + +func (s *Aux_load_data_from_files_options_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Aux_load_data_from_files_options_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Aux_load_data_from_files_options_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterAux_load_data_from_files_options_list(s) + } +} + +func (s *Aux_load_data_from_files_options_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitAux_load_data_from_files_options_list(s) + } +} + +func (s *Aux_load_data_from_files_options_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitAux_load_data_from_files_options_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Aux_load_data_from_files_options_list() (localctx IAux_load_data_from_files_options_listContext) { + localctx = NewAux_load_data_from_files_options_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 542, GoogleSQLParserRULE_aux_load_data_from_files_options_list) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3782) + p.Match(GoogleSQLParserFROM_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3783) + p.Match(GoogleSQLParserFILES_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3784) + p.Options_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICluster_by_clause_prefix_no_hintContext is an interface to support dynamic dispatch. +type ICluster_by_clause_prefix_no_hintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CLUSTER_SYMBOL() antlr.TerminalNode + BY_SYMBOL() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsCluster_by_clause_prefix_no_hintContext differentiates from other interfaces. + IsCluster_by_clause_prefix_no_hintContext() +} + +type Cluster_by_clause_prefix_no_hintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCluster_by_clause_prefix_no_hintContext() *Cluster_by_clause_prefix_no_hintContext { + var p = new(Cluster_by_clause_prefix_no_hintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_cluster_by_clause_prefix_no_hint + return p +} + +func InitEmptyCluster_by_clause_prefix_no_hintContext(p *Cluster_by_clause_prefix_no_hintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_cluster_by_clause_prefix_no_hint +} + +func (*Cluster_by_clause_prefix_no_hintContext) IsCluster_by_clause_prefix_no_hintContext() {} + +func NewCluster_by_clause_prefix_no_hintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cluster_by_clause_prefix_no_hintContext { + var p = new(Cluster_by_clause_prefix_no_hintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_cluster_by_clause_prefix_no_hint + + return p +} + +func (s *Cluster_by_clause_prefix_no_hintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cluster_by_clause_prefix_no_hintContext) CLUSTER_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCLUSTER_SYMBOL, 0) +} + +func (s *Cluster_by_clause_prefix_no_hintContext) BY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBY_SYMBOL, 0) +} + +func (s *Cluster_by_clause_prefix_no_hintContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Cluster_by_clause_prefix_no_hintContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Cluster_by_clause_prefix_no_hintContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Cluster_by_clause_prefix_no_hintContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Cluster_by_clause_prefix_no_hintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cluster_by_clause_prefix_no_hintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cluster_by_clause_prefix_no_hintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCluster_by_clause_prefix_no_hint(s) + } +} + +func (s *Cluster_by_clause_prefix_no_hintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCluster_by_clause_prefix_no_hint(s) + } +} + +func (s *Cluster_by_clause_prefix_no_hintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCluster_by_clause_prefix_no_hint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Cluster_by_clause_prefix_no_hint() (localctx ICluster_by_clause_prefix_no_hintContext) { + localctx = NewCluster_by_clause_prefix_no_hintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 544, GoogleSQLParserRULE_cluster_by_clause_prefix_no_hint) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3786) + p.Match(GoogleSQLParserCLUSTER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3787) + p.Match(GoogleSQLParserBY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3788) + p.expression(0) + } + p.SetState(3793) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(3789) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3790) + p.expression(0) + } + + p.SetState(3795) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILoad_data_partitions_clauseContext is an interface to support dynamic dispatch. +type ILoad_data_partitions_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITIONS_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + OVERWRITE_SYMBOL() antlr.TerminalNode + + // IsLoad_data_partitions_clauseContext differentiates from other interfaces. + IsLoad_data_partitions_clauseContext() +} + +type Load_data_partitions_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLoad_data_partitions_clauseContext() *Load_data_partitions_clauseContext { + var p = new(Load_data_partitions_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_load_data_partitions_clause + return p +} + +func InitEmptyLoad_data_partitions_clauseContext(p *Load_data_partitions_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_load_data_partitions_clause +} + +func (*Load_data_partitions_clauseContext) IsLoad_data_partitions_clauseContext() {} + +func NewLoad_data_partitions_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Load_data_partitions_clauseContext { + var p = new(Load_data_partitions_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_load_data_partitions_clause + + return p +} + +func (s *Load_data_partitions_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Load_data_partitions_clauseContext) PARTITIONS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPARTITIONS_SYMBOL, 0) +} + +func (s *Load_data_partitions_clauseContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Load_data_partitions_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Load_data_partitions_clauseContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Load_data_partitions_clauseContext) OVERWRITE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOVERWRITE_SYMBOL, 0) +} + +func (s *Load_data_partitions_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Load_data_partitions_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Load_data_partitions_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterLoad_data_partitions_clause(s) + } +} + +func (s *Load_data_partitions_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitLoad_data_partitions_clause(s) + } +} + +func (s *Load_data_partitions_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitLoad_data_partitions_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Load_data_partitions_clause() (localctx ILoad_data_partitions_clauseContext) { + localctx = NewLoad_data_partitions_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 546, GoogleSQLParserRULE_load_data_partitions_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(3797) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOVERWRITE_SYMBOL { + { + p.SetState(3796) + p.Match(GoogleSQLParserOVERWRITE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3799) + p.Match(GoogleSQLParserPARTITIONS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3800) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3801) + p.expression(0) + } + { + p.SetState(3802) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMaybe_dashed_path_expression_with_scopeContext is an interface to support dynamic dispatch. +type IMaybe_dashed_path_expression_with_scopeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TEMP_SYMBOL() antlr.TerminalNode + TABLE_SYMBOL() antlr.TerminalNode + Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext + TEMPORARY_SYMBOL() antlr.TerminalNode + + // IsMaybe_dashed_path_expression_with_scopeContext differentiates from other interfaces. + IsMaybe_dashed_path_expression_with_scopeContext() +} + +type Maybe_dashed_path_expression_with_scopeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMaybe_dashed_path_expression_with_scopeContext() *Maybe_dashed_path_expression_with_scopeContext { + var p = new(Maybe_dashed_path_expression_with_scopeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_maybe_dashed_path_expression_with_scope + return p +} + +func InitEmptyMaybe_dashed_path_expression_with_scopeContext(p *Maybe_dashed_path_expression_with_scopeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_maybe_dashed_path_expression_with_scope +} + +func (*Maybe_dashed_path_expression_with_scopeContext) IsMaybe_dashed_path_expression_with_scopeContext() { +} + +func NewMaybe_dashed_path_expression_with_scopeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Maybe_dashed_path_expression_with_scopeContext { + var p = new(Maybe_dashed_path_expression_with_scopeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_maybe_dashed_path_expression_with_scope + + return p +} + +func (s *Maybe_dashed_path_expression_with_scopeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Maybe_dashed_path_expression_with_scopeContext) TEMP_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTEMP_SYMBOL, 0) +} + +func (s *Maybe_dashed_path_expression_with_scopeContext) TABLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTABLE_SYMBOL, 0) +} + +func (s *Maybe_dashed_path_expression_with_scopeContext) Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_dashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_dashed_path_expressionContext) +} + +func (s *Maybe_dashed_path_expression_with_scopeContext) TEMPORARY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTEMPORARY_SYMBOL, 0) +} + +func (s *Maybe_dashed_path_expression_with_scopeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Maybe_dashed_path_expression_with_scopeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Maybe_dashed_path_expression_with_scopeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterMaybe_dashed_path_expression_with_scope(s) + } +} + +func (s *Maybe_dashed_path_expression_with_scopeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitMaybe_dashed_path_expression_with_scope(s) + } +} + +func (s *Maybe_dashed_path_expression_with_scopeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitMaybe_dashed_path_expression_with_scope(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Maybe_dashed_path_expression_with_scope() (localctx IMaybe_dashed_path_expression_with_scopeContext) { + localctx = NewMaybe_dashed_path_expression_with_scopeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 548, GoogleSQLParserRULE_maybe_dashed_path_expression_with_scope) + p.SetState(3811) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 443, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3804) + p.Match(GoogleSQLParserTEMP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3805) + p.Match(GoogleSQLParserTABLE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3806) + p.Maybe_dashed_path_expression() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3807) + p.Match(GoogleSQLParserTEMPORARY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3808) + p.Match(GoogleSQLParserTABLE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3809) + p.Maybe_dashed_path_expression() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3810) + p.Maybe_dashed_path_expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_element_listContext is an interface to support dynamic dispatch. +type ITable_element_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + RR_BRACKET_SYMBOL() antlr.TerminalNode + AllTable_element() []ITable_elementContext + Table_element(i int) ITable_elementContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsTable_element_listContext differentiates from other interfaces. + IsTable_element_listContext() +} + +type Table_element_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_element_listContext() *Table_element_listContext { + var p = new(Table_element_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_element_list + return p +} + +func InitEmptyTable_element_listContext(p *Table_element_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_element_list +} + +func (*Table_element_listContext) IsTable_element_listContext() {} + +func NewTable_element_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_element_listContext { + var p = new(Table_element_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_table_element_list + + return p +} + +func (s *Table_element_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_element_listContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Table_element_listContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Table_element_listContext) AllTable_element() []ITable_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_elementContext); ok { + len++ + } + } + + tst := make([]ITable_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_elementContext); ok { + tst[i] = t.(ITable_elementContext) + i++ + } + } + + return tst +} + +func (s *Table_element_listContext) Table_element(i int) ITable_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_elementContext) +} + +func (s *Table_element_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Table_element_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Table_element_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_element_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_element_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTable_element_list(s) + } +} + +func (s *Table_element_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTable_element_list(s) + } +} + +func (s *Table_element_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTable_element_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Table_element_list() (localctx ITable_element_listContext) { + localctx = NewTable_element_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 550, GoogleSQLParserRULE_table_element_list) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3813) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3825) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-74)) & ^0x3f) == 0 && ((int64(1)<<(_la-74))&-106523215214079) != 0) || ((int64((_la-138)) & ^0x3f) == 0 && ((int64(1)<<(_la-138))&-1) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-36028797018963969) != 0) || ((int64((_la-266)) & ^0x3f) == 0 && ((int64(1)<<(_la-266))&536870911) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&33488865) != 0) { + { + p.SetState(3814) + p.Table_element() + } + p.SetState(3819) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 444, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3815) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3816) + p.Table_element() + } + + } + p.SetState(3821) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 444, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(3823) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(3822) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + { + p.SetState(3827) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_elementContext is an interface to support dynamic dispatch. +type ITable_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_column_definition() ITable_column_definitionContext + Table_constraint_definition() ITable_constraint_definitionContext + + // IsTable_elementContext differentiates from other interfaces. + IsTable_elementContext() +} + +type Table_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_elementContext() *Table_elementContext { + var p = new(Table_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_element + return p +} + +func InitEmptyTable_elementContext(p *Table_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_element +} + +func (*Table_elementContext) IsTable_elementContext() {} + +func NewTable_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_elementContext { + var p = new(Table_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_table_element + + return p +} + +func (s *Table_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_elementContext) Table_column_definition() ITable_column_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_column_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_column_definitionContext) +} + +func (s *Table_elementContext) Table_constraint_definition() ITable_constraint_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_constraint_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_constraint_definitionContext) +} + +func (s *Table_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTable_element(s) + } +} + +func (s *Table_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTable_element(s) + } +} + +func (s *Table_elementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTable_element(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Table_element() (localctx ITable_elementContext) { + localctx = NewTable_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 552, GoogleSQLParserRULE_table_element) + p.SetState(3831) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 447, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3829) + p.Table_column_definition() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3830) + p.Table_constraint_definition() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_constraint_definitionContext is an interface to support dynamic dispatch. +type ITable_constraint_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Primary_key_spec() IPrimary_key_specContext + Table_constraint_spec() ITable_constraint_specContext + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + + // IsTable_constraint_definitionContext differentiates from other interfaces. + IsTable_constraint_definitionContext() +} + +type Table_constraint_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_constraint_definitionContext() *Table_constraint_definitionContext { + var p = new(Table_constraint_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_constraint_definition + return p +} + +func InitEmptyTable_constraint_definitionContext(p *Table_constraint_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_constraint_definition +} + +func (*Table_constraint_definitionContext) IsTable_constraint_definitionContext() {} + +func NewTable_constraint_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_constraint_definitionContext { + var p = new(Table_constraint_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_table_constraint_definition + + return p +} + +func (s *Table_constraint_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_constraint_definitionContext) Primary_key_spec() IPrimary_key_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimary_key_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimary_key_specContext) +} + +func (s *Table_constraint_definitionContext) Table_constraint_spec() ITable_constraint_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_constraint_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_constraint_specContext) +} + +func (s *Table_constraint_definitionContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Table_constraint_definitionContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Table_constraint_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_constraint_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_constraint_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTable_constraint_definition(s) + } +} + +func (s *Table_constraint_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTable_constraint_definition(s) + } +} + +func (s *Table_constraint_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTable_constraint_definition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Table_constraint_definition() (localctx ITable_constraint_definitionContext) { + localctx = NewTable_constraint_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 554, GoogleSQLParserRULE_table_constraint_definition) + p.SetState(3839) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 448, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3833) + p.Primary_key_spec() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3834) + p.Table_constraint_spec() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3835) + p.Identifier() + } + { + p.SetState(3836) + p.Identifier() + } + { + p.SetState(3837) + p.Table_constraint_spec() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAppend_or_overwriteContext is an interface to support dynamic dispatch. +type IAppend_or_overwriteContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INTO_SYMBOL() antlr.TerminalNode + OVERWRITE_SYMBOL() antlr.TerminalNode + + // IsAppend_or_overwriteContext differentiates from other interfaces. + IsAppend_or_overwriteContext() +} + +type Append_or_overwriteContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAppend_or_overwriteContext() *Append_or_overwriteContext { + var p = new(Append_or_overwriteContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_append_or_overwrite + return p +} + +func InitEmptyAppend_or_overwriteContext(p *Append_or_overwriteContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_append_or_overwrite +} + +func (*Append_or_overwriteContext) IsAppend_or_overwriteContext() {} + +func NewAppend_or_overwriteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Append_or_overwriteContext { + var p = new(Append_or_overwriteContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_append_or_overwrite + + return p +} + +func (s *Append_or_overwriteContext) GetParser() antlr.Parser { return s.parser } + +func (s *Append_or_overwriteContext) INTO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINTO_SYMBOL, 0) +} + +func (s *Append_or_overwriteContext) OVERWRITE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOVERWRITE_SYMBOL, 0) +} + +func (s *Append_or_overwriteContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Append_or_overwriteContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Append_or_overwriteContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterAppend_or_overwrite(s) + } +} + +func (s *Append_or_overwriteContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitAppend_or_overwrite(s) + } +} + +func (s *Append_or_overwriteContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitAppend_or_overwrite(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Append_or_overwrite() (localctx IAppend_or_overwriteContext) { + localctx = NewAppend_or_overwriteContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 556, GoogleSQLParserRULE_append_or_overwrite) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3841) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserOVERWRITE_SYMBOL || _la == GoogleSQLParserINTO_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_descriptionContext is an interface to support dynamic dispatch. +type IOpt_descriptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AS_SYMBOL() antlr.TerminalNode + String_literal() IString_literalContext + + // IsOpt_descriptionContext differentiates from other interfaces. + IsOpt_descriptionContext() +} + +type Opt_descriptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_descriptionContext() *Opt_descriptionContext { + var p = new(Opt_descriptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_description + return p +} + +func InitEmptyOpt_descriptionContext(p *Opt_descriptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_description +} + +func (*Opt_descriptionContext) IsOpt_descriptionContext() {} + +func NewOpt_descriptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_descriptionContext { + var p = new(Opt_descriptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_description + + return p +} + +func (s *Opt_descriptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_descriptionContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Opt_descriptionContext) String_literal() IString_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_literalContext) +} + +func (s *Opt_descriptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_descriptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_descriptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_description(s) + } +} + +func (s *Opt_descriptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_description(s) + } +} + +func (s *Opt_descriptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_description(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_description() (localctx IOpt_descriptionContext) { + localctx = NewOpt_descriptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 558, GoogleSQLParserRULE_opt_description) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3843) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3844) + p.string_literal(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_and_column_info_listContext is an interface to support dynamic dispatch. +type ITable_and_column_info_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTable_and_column_info() []ITable_and_column_infoContext + Table_and_column_info(i int) ITable_and_column_infoContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsTable_and_column_info_listContext differentiates from other interfaces. + IsTable_and_column_info_listContext() +} + +type Table_and_column_info_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_and_column_info_listContext() *Table_and_column_info_listContext { + var p = new(Table_and_column_info_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_and_column_info_list + return p +} + +func InitEmptyTable_and_column_info_listContext(p *Table_and_column_info_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_and_column_info_list +} + +func (*Table_and_column_info_listContext) IsTable_and_column_info_listContext() {} + +func NewTable_and_column_info_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_and_column_info_listContext { + var p = new(Table_and_column_info_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_table_and_column_info_list + + return p +} + +func (s *Table_and_column_info_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_and_column_info_listContext) AllTable_and_column_info() []ITable_and_column_infoContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_and_column_infoContext); ok { + len++ + } + } + + tst := make([]ITable_and_column_infoContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_and_column_infoContext); ok { + tst[i] = t.(ITable_and_column_infoContext) + i++ + } + } + + return tst +} + +func (s *Table_and_column_info_listContext) Table_and_column_info(i int) ITable_and_column_infoContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_and_column_infoContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_and_column_infoContext) +} + +func (s *Table_and_column_info_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Table_and_column_info_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Table_and_column_info_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_and_column_info_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_and_column_info_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTable_and_column_info_list(s) + } +} + +func (s *Table_and_column_info_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTable_and_column_info_list(s) + } +} + +func (s *Table_and_column_info_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTable_and_column_info_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Table_and_column_info_list() (localctx ITable_and_column_info_listContext) { + localctx = NewTable_and_column_info_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 560, GoogleSQLParserRULE_table_and_column_info_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3846) + p.Table_and_column_info() + } + p.SetState(3851) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(3847) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3848) + p.Table_and_column_info() + } + + p.SetState(3853) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_and_column_infoContext is an interface to support dynamic dispatch. +type ITable_and_column_infoContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext + Column_list() IColumn_listContext + + // IsTable_and_column_infoContext differentiates from other interfaces. + IsTable_and_column_infoContext() +} + +type Table_and_column_infoContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_and_column_infoContext() *Table_and_column_infoContext { + var p = new(Table_and_column_infoContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_and_column_info + return p +} + +func InitEmptyTable_and_column_infoContext(p *Table_and_column_infoContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_and_column_info +} + +func (*Table_and_column_infoContext) IsTable_and_column_infoContext() {} + +func NewTable_and_column_infoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_and_column_infoContext { + var p = new(Table_and_column_infoContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_table_and_column_info + + return p +} + +func (s *Table_and_column_infoContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_and_column_infoContext) Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_dashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_dashed_path_expressionContext) +} + +func (s *Table_and_column_infoContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Table_and_column_infoContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_and_column_infoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_and_column_infoContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTable_and_column_info(s) + } +} + +func (s *Table_and_column_infoContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTable_and_column_info(s) + } +} + +func (s *Table_and_column_infoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTable_and_column_info(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Table_and_column_info() (localctx ITable_and_column_infoContext) { + localctx = NewTable_and_column_infoContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 562, GoogleSQLParserRULE_table_and_column_info) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3854) + p.Maybe_dashed_path_expression() + } + p.SetState(3856) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL { + { + p.SetState(3855) + p.Column_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRow_access_policy_alter_action_listContext is an interface to support dynamic dispatch. +type IRow_access_policy_alter_action_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllRow_access_policy_alter_action() []IRow_access_policy_alter_actionContext + Row_access_policy_alter_action(i int) IRow_access_policy_alter_actionContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsRow_access_policy_alter_action_listContext differentiates from other interfaces. + IsRow_access_policy_alter_action_listContext() +} + +type Row_access_policy_alter_action_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRow_access_policy_alter_action_listContext() *Row_access_policy_alter_action_listContext { + var p = new(Row_access_policy_alter_action_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_row_access_policy_alter_action_list + return p +} + +func InitEmptyRow_access_policy_alter_action_listContext(p *Row_access_policy_alter_action_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_row_access_policy_alter_action_list +} + +func (*Row_access_policy_alter_action_listContext) IsRow_access_policy_alter_action_listContext() {} + +func NewRow_access_policy_alter_action_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Row_access_policy_alter_action_listContext { + var p = new(Row_access_policy_alter_action_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_row_access_policy_alter_action_list + + return p +} + +func (s *Row_access_policy_alter_action_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Row_access_policy_alter_action_listContext) AllRow_access_policy_alter_action() []IRow_access_policy_alter_actionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRow_access_policy_alter_actionContext); ok { + len++ + } + } + + tst := make([]IRow_access_policy_alter_actionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRow_access_policy_alter_actionContext); ok { + tst[i] = t.(IRow_access_policy_alter_actionContext) + i++ + } + } + + return tst +} + +func (s *Row_access_policy_alter_action_listContext) Row_access_policy_alter_action(i int) IRow_access_policy_alter_actionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRow_access_policy_alter_actionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRow_access_policy_alter_actionContext) +} + +func (s *Row_access_policy_alter_action_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Row_access_policy_alter_action_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Row_access_policy_alter_action_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Row_access_policy_alter_action_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Row_access_policy_alter_action_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterRow_access_policy_alter_action_list(s) + } +} + +func (s *Row_access_policy_alter_action_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitRow_access_policy_alter_action_list(s) + } +} + +func (s *Row_access_policy_alter_action_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitRow_access_policy_alter_action_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Row_access_policy_alter_action_list() (localctx IRow_access_policy_alter_action_listContext) { + localctx = NewRow_access_policy_alter_action_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 564, GoogleSQLParserRULE_row_access_policy_alter_action_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3858) + p.Row_access_policy_alter_action() + } + p.SetState(3863) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(3859) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3860) + p.Row_access_policy_alter_action() + } + + p.SetState(3865) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRow_access_policy_alter_actionContext is an interface to support dynamic dispatch. +type IRow_access_policy_alter_actionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Grant_to_clause() IGrant_to_clauseContext + FILTER_SYMBOL() antlr.TerminalNode + USING_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + REVOKE_SYMBOL() antlr.TerminalNode + FROM_SYMBOL() antlr.TerminalNode + Grantee_list() IGrantee_listContext + ALL_SYMBOL() antlr.TerminalNode + RENAME_SYMBOL() antlr.TerminalNode + TO_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsRow_access_policy_alter_actionContext differentiates from other interfaces. + IsRow_access_policy_alter_actionContext() +} + +type Row_access_policy_alter_actionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRow_access_policy_alter_actionContext() *Row_access_policy_alter_actionContext { + var p = new(Row_access_policy_alter_actionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_row_access_policy_alter_action + return p +} + +func InitEmptyRow_access_policy_alter_actionContext(p *Row_access_policy_alter_actionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_row_access_policy_alter_action +} + +func (*Row_access_policy_alter_actionContext) IsRow_access_policy_alter_actionContext() {} + +func NewRow_access_policy_alter_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Row_access_policy_alter_actionContext { + var p = new(Row_access_policy_alter_actionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_row_access_policy_alter_action + + return p +} + +func (s *Row_access_policy_alter_actionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Row_access_policy_alter_actionContext) Grant_to_clause() IGrant_to_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_to_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_to_clauseContext) +} + +func (s *Row_access_policy_alter_actionContext) FILTER_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFILTER_SYMBOL, 0) +} + +func (s *Row_access_policy_alter_actionContext) USING_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUSING_SYMBOL, 0) +} + +func (s *Row_access_policy_alter_actionContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Row_access_policy_alter_actionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Row_access_policy_alter_actionContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Row_access_policy_alter_actionContext) REVOKE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREVOKE_SYMBOL, 0) +} + +func (s *Row_access_policy_alter_actionContext) FROM_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFROM_SYMBOL, 0) +} + +func (s *Row_access_policy_alter_actionContext) Grantee_list() IGrantee_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_listContext) +} + +func (s *Row_access_policy_alter_actionContext) ALL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserALL_SYMBOL, 0) +} + +func (s *Row_access_policy_alter_actionContext) RENAME_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRENAME_SYMBOL, 0) +} + +func (s *Row_access_policy_alter_actionContext) TO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTO_SYMBOL, 0) +} + +func (s *Row_access_policy_alter_actionContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Row_access_policy_alter_actionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Row_access_policy_alter_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Row_access_policy_alter_actionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterRow_access_policy_alter_action(s) + } +} + +func (s *Row_access_policy_alter_actionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitRow_access_policy_alter_action(s) + } +} + +func (s *Row_access_policy_alter_actionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitRow_access_policy_alter_action(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Row_access_policy_alter_action() (localctx IRow_access_policy_alter_actionContext) { + localctx = NewRow_access_policy_alter_actionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 566, GoogleSQLParserRULE_row_access_policy_alter_action) + p.SetState(3885) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 452, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3866) + p.Grant_to_clause() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3867) + p.Match(GoogleSQLParserFILTER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3868) + p.Match(GoogleSQLParserUSING_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3869) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3870) + p.expression(0) + } + { + p.SetState(3871) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3873) + p.Match(GoogleSQLParserREVOKE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3874) + p.Match(GoogleSQLParserFROM_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3875) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3876) + p.Grantee_list() + } + { + p.SetState(3877) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3879) + p.Match(GoogleSQLParserREVOKE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3880) + p.Match(GoogleSQLParserFROM_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3881) + p.Match(GoogleSQLParserALL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3882) + p.Match(GoogleSQLParserRENAME_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3883) + p.Match(GoogleSQLParserTO_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3884) + p.Identifier() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrant_to_clauseContext is an interface to support dynamic dispatch. +type IGrant_to_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANT_SYMBOL() antlr.TerminalNode + TO_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + Grantee_list() IGrantee_listContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsGrant_to_clauseContext differentiates from other interfaces. + IsGrant_to_clauseContext() +} + +type Grant_to_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_to_clauseContext() *Grant_to_clauseContext { + var p = new(Grant_to_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_grant_to_clause + return p +} + +func InitEmptyGrant_to_clauseContext(p *Grant_to_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_grant_to_clause +} + +func (*Grant_to_clauseContext) IsGrant_to_clauseContext() {} + +func NewGrant_to_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_to_clauseContext { + var p = new(Grant_to_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_grant_to_clause + + return p +} + +func (s *Grant_to_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_to_clauseContext) GRANT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserGRANT_SYMBOL, 0) +} + +func (s *Grant_to_clauseContext) TO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTO_SYMBOL, 0) +} + +func (s *Grant_to_clauseContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Grant_to_clauseContext) Grantee_list() IGrantee_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_listContext) +} + +func (s *Grant_to_clauseContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Grant_to_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_to_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_to_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGrant_to_clause(s) + } +} + +func (s *Grant_to_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGrant_to_clause(s) + } +} + +func (s *Grant_to_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGrant_to_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Grant_to_clause() (localctx IGrant_to_clauseContext) { + localctx = NewGrant_to_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 568, GoogleSQLParserRULE_grant_to_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3887) + p.Match(GoogleSQLParserGRANT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3888) + p.Match(GoogleSQLParserTO_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3889) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3890) + p.Grantee_list() + } + { + p.SetState(3891) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrantee_listContext is an interface to support dynamic dispatch. +type IGrantee_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllString_literal_or_parameter() []IString_literal_or_parameterContext + String_literal_or_parameter(i int) IString_literal_or_parameterContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsGrantee_listContext differentiates from other interfaces. + IsGrantee_listContext() +} + +type Grantee_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrantee_listContext() *Grantee_listContext { + var p = new(Grantee_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_grantee_list + return p +} + +func InitEmptyGrantee_listContext(p *Grantee_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_grantee_list +} + +func (*Grantee_listContext) IsGrantee_listContext() {} + +func NewGrantee_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grantee_listContext { + var p = new(Grantee_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_grantee_list + + return p +} + +func (s *Grantee_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grantee_listContext) AllString_literal_or_parameter() []IString_literal_or_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IString_literal_or_parameterContext); ok { + len++ + } + } + + tst := make([]IString_literal_or_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IString_literal_or_parameterContext); ok { + tst[i] = t.(IString_literal_or_parameterContext) + i++ + } + } + + return tst +} + +func (s *Grantee_listContext) String_literal_or_parameter(i int) IString_literal_or_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_literal_or_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IString_literal_or_parameterContext) +} + +func (s *Grantee_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Grantee_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Grantee_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grantee_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grantee_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGrantee_list(s) + } +} + +func (s *Grantee_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGrantee_list(s) + } +} + +func (s *Grantee_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGrantee_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Grantee_list() (localctx IGrantee_listContext) { + localctx = NewGrantee_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 570, GoogleSQLParserRULE_grantee_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3893) + p.String_literal_or_parameter() + } + p.SetState(3898) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(3894) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3895) + p.String_literal_or_parameter() + } + + p.SetState(3900) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrivilege_listContext is an interface to support dynamic dispatch. +type IPrivilege_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllPrivilege() []IPrivilegeContext + Privilege(i int) IPrivilegeContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsPrivilege_listContext differentiates from other interfaces. + IsPrivilege_listContext() +} + +type Privilege_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrivilege_listContext() *Privilege_listContext { + var p = new(Privilege_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_privilege_list + return p +} + +func InitEmptyPrivilege_listContext(p *Privilege_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_privilege_list +} + +func (*Privilege_listContext) IsPrivilege_listContext() {} + +func NewPrivilege_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Privilege_listContext { + var p = new(Privilege_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_privilege_list + + return p +} + +func (s *Privilege_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Privilege_listContext) AllPrivilege() []IPrivilegeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPrivilegeContext); ok { + len++ + } + } + + tst := make([]IPrivilegeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPrivilegeContext); ok { + tst[i] = t.(IPrivilegeContext) + i++ + } + } + + return tst +} + +func (s *Privilege_listContext) Privilege(i int) IPrivilegeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilegeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPrivilegeContext) +} + +func (s *Privilege_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Privilege_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Privilege_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Privilege_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Privilege_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPrivilege_list(s) + } +} + +func (s *Privilege_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPrivilege_list(s) + } +} + +func (s *Privilege_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPrivilege_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Privilege_list() (localctx IPrivilege_listContext) { + localctx = NewPrivilege_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 572, GoogleSQLParserRULE_privilege_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3901) + p.Privilege() + } + p.SetState(3906) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(3902) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3903) + p.Privilege() + } + + p.SetState(3908) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrivilegeContext is an interface to support dynamic dispatch. +type IPrivilegeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Privilege_name() IPrivilege_nameContext + Path_expression_list_with_parens() IPath_expression_list_with_parensContext + + // IsPrivilegeContext differentiates from other interfaces. + IsPrivilegeContext() +} + +type PrivilegeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrivilegeContext() *PrivilegeContext { + var p = new(PrivilegeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_privilege + return p +} + +func InitEmptyPrivilegeContext(p *PrivilegeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_privilege +} + +func (*PrivilegeContext) IsPrivilegeContext() {} + +func NewPrivilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrivilegeContext { + var p = new(PrivilegeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_privilege + + return p +} + +func (s *PrivilegeContext) GetParser() antlr.Parser { return s.parser } + +func (s *PrivilegeContext) Privilege_name() IPrivilege_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilege_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrivilege_nameContext) +} + +func (s *PrivilegeContext) Path_expression_list_with_parens() IPath_expression_list_with_parensContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expression_list_with_parensContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expression_list_with_parensContext) +} + +func (s *PrivilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PrivilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PrivilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPrivilege(s) + } +} + +func (s *PrivilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPrivilege(s) + } +} + +func (s *PrivilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPrivilege(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Privilege() (localctx IPrivilegeContext) { + localctx = NewPrivilegeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 574, GoogleSQLParserRULE_privilege) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3909) + p.Privilege_name() + } + p.SetState(3911) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL { + { + p.SetState(3910) + p.Path_expression_list_with_parens() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPath_expression_list_with_parensContext is an interface to support dynamic dispatch. +type IPath_expression_list_with_parensContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + Path_expression_list() IPath_expression_listContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsPath_expression_list_with_parensContext differentiates from other interfaces. + IsPath_expression_list_with_parensContext() +} + +type Path_expression_list_with_parensContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPath_expression_list_with_parensContext() *Path_expression_list_with_parensContext { + var p = new(Path_expression_list_with_parensContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_path_expression_list_with_parens + return p +} + +func InitEmptyPath_expression_list_with_parensContext(p *Path_expression_list_with_parensContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_path_expression_list_with_parens +} + +func (*Path_expression_list_with_parensContext) IsPath_expression_list_with_parensContext() {} + +func NewPath_expression_list_with_parensContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Path_expression_list_with_parensContext { + var p = new(Path_expression_list_with_parensContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_path_expression_list_with_parens + + return p +} + +func (s *Path_expression_list_with_parensContext) GetParser() antlr.Parser { return s.parser } + +func (s *Path_expression_list_with_parensContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Path_expression_list_with_parensContext) Path_expression_list() IPath_expression_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expression_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expression_listContext) +} + +func (s *Path_expression_list_with_parensContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Path_expression_list_with_parensContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Path_expression_list_with_parensContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Path_expression_list_with_parensContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPath_expression_list_with_parens(s) + } +} + +func (s *Path_expression_list_with_parensContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPath_expression_list_with_parens(s) + } +} + +func (s *Path_expression_list_with_parensContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPath_expression_list_with_parens(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Path_expression_list_with_parens() (localctx IPath_expression_list_with_parensContext) { + localctx = NewPath_expression_list_with_parensContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 576, GoogleSQLParserRULE_path_expression_list_with_parens) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3913) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3914) + p.Path_expression_list() + } + { + p.SetState(3915) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrivilege_nameContext is an interface to support dynamic dispatch. +type IPrivilege_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + SELECT_SYMBOL() antlr.TerminalNode + + // IsPrivilege_nameContext differentiates from other interfaces. + IsPrivilege_nameContext() +} + +type Privilege_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrivilege_nameContext() *Privilege_nameContext { + var p = new(Privilege_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_privilege_name + return p +} + +func InitEmptyPrivilege_nameContext(p *Privilege_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_privilege_name +} + +func (*Privilege_nameContext) IsPrivilege_nameContext() {} + +func NewPrivilege_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Privilege_nameContext { + var p = new(Privilege_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_privilege_name + + return p +} + +func (s *Privilege_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Privilege_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Privilege_nameContext) SELECT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSELECT_SYMBOL, 0) +} + +func (s *Privilege_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Privilege_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Privilege_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPrivilege_name(s) + } +} + +func (s *Privilege_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPrivilege_name(s) + } +} + +func (s *Privilege_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPrivilege_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Privilege_name() (localctx IPrivilege_nameContext) { + localctx = NewPrivilege_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 578, GoogleSQLParserRULE_privilege_name) + p.SetState(3919) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3917) + p.Identifier() + } + + case GoogleSQLParserSELECT_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3918) + p.Match(GoogleSQLParserSELECT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGeneric_entity_typeContext is an interface to support dynamic dispatch. +type IGeneric_entity_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Generic_entity_type_unchecked() IGeneric_entity_type_uncheckedContext + + // IsGeneric_entity_typeContext differentiates from other interfaces. + IsGeneric_entity_typeContext() +} + +type Generic_entity_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGeneric_entity_typeContext() *Generic_entity_typeContext { + var p = new(Generic_entity_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_generic_entity_type + return p +} + +func InitEmptyGeneric_entity_typeContext(p *Generic_entity_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_generic_entity_type +} + +func (*Generic_entity_typeContext) IsGeneric_entity_typeContext() {} + +func NewGeneric_entity_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generic_entity_typeContext { + var p = new(Generic_entity_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_generic_entity_type + + return p +} + +func (s *Generic_entity_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Generic_entity_typeContext) Generic_entity_type_unchecked() IGeneric_entity_type_uncheckedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneric_entity_type_uncheckedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneric_entity_type_uncheckedContext) +} + +func (s *Generic_entity_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Generic_entity_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Generic_entity_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGeneric_entity_type(s) + } +} + +func (s *Generic_entity_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGeneric_entity_type(s) + } +} + +func (s *Generic_entity_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGeneric_entity_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Generic_entity_type() (localctx IGeneric_entity_typeContext) { + localctx = NewGeneric_entity_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 580, GoogleSQLParserRULE_generic_entity_type) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3921) + p.Generic_entity_type_unchecked() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGeneric_entity_type_uncheckedContext is an interface to support dynamic dispatch. +type IGeneric_entity_type_uncheckedContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IDENTIFIER() antlr.TerminalNode + PROJECT_SYMBOL() antlr.TerminalNode + + // IsGeneric_entity_type_uncheckedContext differentiates from other interfaces. + IsGeneric_entity_type_uncheckedContext() +} + +type Generic_entity_type_uncheckedContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGeneric_entity_type_uncheckedContext() *Generic_entity_type_uncheckedContext { + var p = new(Generic_entity_type_uncheckedContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_generic_entity_type_unchecked + return p +} + +func InitEmptyGeneric_entity_type_uncheckedContext(p *Generic_entity_type_uncheckedContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_generic_entity_type_unchecked +} + +func (*Generic_entity_type_uncheckedContext) IsGeneric_entity_type_uncheckedContext() {} + +func NewGeneric_entity_type_uncheckedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generic_entity_type_uncheckedContext { + var p = new(Generic_entity_type_uncheckedContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_generic_entity_type_unchecked + + return p +} + +func (s *Generic_entity_type_uncheckedContext) GetParser() antlr.Parser { return s.parser } + +func (s *Generic_entity_type_uncheckedContext) IDENTIFIER() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIDENTIFIER, 0) +} + +func (s *Generic_entity_type_uncheckedContext) PROJECT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPROJECT_SYMBOL, 0) +} + +func (s *Generic_entity_type_uncheckedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Generic_entity_type_uncheckedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Generic_entity_type_uncheckedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGeneric_entity_type_unchecked(s) + } +} + +func (s *Generic_entity_type_uncheckedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGeneric_entity_type_unchecked(s) + } +} + +func (s *Generic_entity_type_uncheckedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGeneric_entity_type_unchecked(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Generic_entity_type_unchecked() (localctx IGeneric_entity_type_uncheckedContext) { + localctx = NewGeneric_entity_type_uncheckedContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 582, GoogleSQLParserRULE_generic_entity_type_unchecked) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3923) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserPROJECT_SYMBOL || _la == GoogleSQLParserIDENTIFIER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISchema_object_kindContext is an interface to support dynamic dispatch. +type ISchema_object_kindContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AGGREGATE_SYMBOL() antlr.TerminalNode + FUNCTION_SYMBOL() antlr.TerminalNode + APPROX_SYMBOL() antlr.TerminalNode + VIEW_SYMBOL() antlr.TerminalNode + CONNECTION_SYMBOL() antlr.TerminalNode + CONSTANT_SYMBOL() antlr.TerminalNode + DATABASE_SYMBOL() antlr.TerminalNode + EXTERNAL_SYMBOL() antlr.TerminalNode + Table_or_table_function() ITable_or_table_functionContext + SCHEMA_SYMBOL() antlr.TerminalNode + INDEX_SYMBOL() antlr.TerminalNode + MATERIALIZED_SYMBOL() antlr.TerminalNode + MODEL_SYMBOL() antlr.TerminalNode + PROCEDURE_SYMBOL() antlr.TerminalNode + + // IsSchema_object_kindContext differentiates from other interfaces. + IsSchema_object_kindContext() +} + +type Schema_object_kindContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySchema_object_kindContext() *Schema_object_kindContext { + var p = new(Schema_object_kindContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_schema_object_kind + return p +} + +func InitEmptySchema_object_kindContext(p *Schema_object_kindContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_schema_object_kind +} + +func (*Schema_object_kindContext) IsSchema_object_kindContext() {} + +func NewSchema_object_kindContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Schema_object_kindContext { + var p = new(Schema_object_kindContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_schema_object_kind + + return p +} + +func (s *Schema_object_kindContext) GetParser() antlr.Parser { return s.parser } + +func (s *Schema_object_kindContext) AGGREGATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAGGREGATE_SYMBOL, 0) +} + +func (s *Schema_object_kindContext) FUNCTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFUNCTION_SYMBOL, 0) +} + +func (s *Schema_object_kindContext) APPROX_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAPPROX_SYMBOL, 0) +} + +func (s *Schema_object_kindContext) VIEW_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserVIEW_SYMBOL, 0) +} + +func (s *Schema_object_kindContext) CONNECTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCONNECTION_SYMBOL, 0) +} + +func (s *Schema_object_kindContext) CONSTANT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCONSTANT_SYMBOL, 0) +} + +func (s *Schema_object_kindContext) DATABASE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDATABASE_SYMBOL, 0) +} + +func (s *Schema_object_kindContext) EXTERNAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXTERNAL_SYMBOL, 0) +} + +func (s *Schema_object_kindContext) Table_or_table_function() ITable_or_table_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_or_table_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_or_table_functionContext) +} + +func (s *Schema_object_kindContext) SCHEMA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSCHEMA_SYMBOL, 0) +} + +func (s *Schema_object_kindContext) INDEX_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINDEX_SYMBOL, 0) +} + +func (s *Schema_object_kindContext) MATERIALIZED_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMATERIALIZED_SYMBOL, 0) +} + +func (s *Schema_object_kindContext) MODEL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMODEL_SYMBOL, 0) +} + +func (s *Schema_object_kindContext) PROCEDURE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPROCEDURE_SYMBOL, 0) +} + +func (s *Schema_object_kindContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Schema_object_kindContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Schema_object_kindContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSchema_object_kind(s) + } +} + +func (s *Schema_object_kindContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSchema_object_kind(s) + } +} + +func (s *Schema_object_kindContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSchema_object_kind(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Schema_object_kind() (localctx ISchema_object_kindContext) { + localctx = NewSchema_object_kindContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 584, GoogleSQLParserRULE_schema_object_kind) + p.SetState(3944) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 457, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3925) + p.Match(GoogleSQLParserAGGREGATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3926) + p.Match(GoogleSQLParserFUNCTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3927) + p.Match(GoogleSQLParserAPPROX_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3928) + p.Match(GoogleSQLParserVIEW_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3929) + p.Match(GoogleSQLParserCONNECTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3930) + p.Match(GoogleSQLParserCONSTANT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3931) + p.Match(GoogleSQLParserDATABASE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3932) + p.Match(GoogleSQLParserEXTERNAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3933) + p.Table_or_table_function() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(3934) + p.Match(GoogleSQLParserEXTERNAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3935) + p.Match(GoogleSQLParserSCHEMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(3936) + p.Match(GoogleSQLParserFUNCTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(3937) + p.Match(GoogleSQLParserINDEX_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(3938) + p.Match(GoogleSQLParserMATERIALIZED_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3939) + p.Match(GoogleSQLParserVIEW_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(3940) + p.Match(GoogleSQLParserMODEL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(3941) + p.Match(GoogleSQLParserPROCEDURE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(3942) + p.Match(GoogleSQLParserSCHEMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(3943) + p.Match(GoogleSQLParserVIEW_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_action_listContext is an interface to support dynamic dispatch. +type IAlter_action_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllAlter_action() []IAlter_actionContext + Alter_action(i int) IAlter_actionContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsAlter_action_listContext differentiates from other interfaces. + IsAlter_action_listContext() +} + +type Alter_action_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_action_listContext() *Alter_action_listContext { + var p = new(Alter_action_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_alter_action_list + return p +} + +func InitEmptyAlter_action_listContext(p *Alter_action_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_alter_action_list +} + +func (*Alter_action_listContext) IsAlter_action_listContext() {} + +func NewAlter_action_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_action_listContext { + var p = new(Alter_action_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_alter_action_list + + return p +} + +func (s *Alter_action_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_action_listContext) AllAlter_action() []IAlter_actionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlter_actionContext); ok { + len++ + } + } + + tst := make([]IAlter_actionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlter_actionContext); ok { + tst[i] = t.(IAlter_actionContext) + i++ + } + } + + return tst +} + +func (s *Alter_action_listContext) Alter_action(i int) IAlter_actionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_actionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlter_actionContext) +} + +func (s *Alter_action_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Alter_action_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Alter_action_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_action_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_action_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterAlter_action_list(s) + } +} + +func (s *Alter_action_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitAlter_action_list(s) + } +} + +func (s *Alter_action_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitAlter_action_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Alter_action_list() (localctx IAlter_action_listContext) { + localctx = NewAlter_action_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 586, GoogleSQLParserRULE_alter_action_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3946) + p.Alter_action() + } + p.SetState(3951) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(3947) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3948) + p.Alter_action() + } + + p.SetState(3953) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_actionContext is an interface to support dynamic dispatch. +type IAlter_actionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET_SYMBOL() antlr.TerminalNode + OPTIONS_SYMBOL() antlr.TerminalNode + Options_list() IOptions_listContext + AS_SYMBOL() antlr.TerminalNode + Generic_entity_body() IGeneric_entity_bodyContext + ADD_SYMBOL() antlr.TerminalNode + Table_constraint_spec() ITable_constraint_specContext + Primary_key_spec() IPrimary_key_specContext + CONSTRAINT_SYMBOL() antlr.TerminalNode + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + Primary_key_or_table_constraint_spec() IPrimary_key_or_table_constraint_specContext + Opt_if_not_exists() IOpt_if_not_existsContext + DROP_SYMBOL() antlr.TerminalNode + Opt_if_exists() IOpt_if_existsContext + PRIMARY_SYMBOL() antlr.TerminalNode + KEY_SYMBOL() antlr.TerminalNode + ALTER_SYMBOL() antlr.TerminalNode + Constraint_enforcement() IConstraint_enforcementContext + COLUMN_SYMBOL() antlr.TerminalNode + Table_column_definition() ITable_column_definitionContext + Column_position() IColumn_positionContext + Fill_using_expression() IFill_using_expressionContext + RENAME_SYMBOL() antlr.TerminalNode + TO_SYMBOL() antlr.TerminalNode + DATA_SYMBOL() antlr.TerminalNode + TYPE_SYMBOL() antlr.TerminalNode + Field_schema() IField_schemaContext + DEFAULT_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + NOT_SYMBOL() antlr.TerminalNode + NULL_SYMBOL() antlr.TerminalNode + GENERATED_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + Collate_clause() ICollate_clauseContext + ROW_SYMBOL() antlr.TerminalNode + DELETION_SYMBOL() antlr.TerminalNode + POLICY_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + RR_BRACKET_SYMBOL() antlr.TerminalNode + REPLACE_SYMBOL() antlr.TerminalNode + Generic_sub_entity_type() IGeneric_sub_entity_typeContext + Alter_action() IAlter_actionContext + Spanner_alter_column_action() ISpanner_alter_column_actionContext + Spanner_set_on_delete_action() ISpanner_set_on_delete_actionContext + + // IsAlter_actionContext differentiates from other interfaces. + IsAlter_actionContext() +} + +type Alter_actionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_actionContext() *Alter_actionContext { + var p = new(Alter_actionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_alter_action + return p +} + +func InitEmptyAlter_actionContext(p *Alter_actionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_alter_action +} + +func (*Alter_actionContext) IsAlter_actionContext() {} + +func NewAlter_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_actionContext { + var p = new(Alter_actionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_alter_action + + return p +} + +func (s *Alter_actionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_actionContext) SET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSET_SYMBOL, 0) +} + +func (s *Alter_actionContext) OPTIONS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOPTIONS_SYMBOL, 0) +} + +func (s *Alter_actionContext) Options_list() IOptions_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptions_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptions_listContext) +} + +func (s *Alter_actionContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Alter_actionContext) Generic_entity_body() IGeneric_entity_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneric_entity_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneric_entity_bodyContext) +} + +func (s *Alter_actionContext) ADD_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserADD_SYMBOL, 0) +} + +func (s *Alter_actionContext) Table_constraint_spec() ITable_constraint_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_constraint_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_constraint_specContext) +} + +func (s *Alter_actionContext) Primary_key_spec() IPrimary_key_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimary_key_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimary_key_specContext) +} + +func (s *Alter_actionContext) CONSTRAINT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCONSTRAINT_SYMBOL, 0) +} + +func (s *Alter_actionContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Alter_actionContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Alter_actionContext) Primary_key_or_table_constraint_spec() IPrimary_key_or_table_constraint_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimary_key_or_table_constraint_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimary_key_or_table_constraint_specContext) +} + +func (s *Alter_actionContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *Alter_actionContext) DROP_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDROP_SYMBOL, 0) +} + +func (s *Alter_actionContext) Opt_if_exists() IOpt_if_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_existsContext) +} + +func (s *Alter_actionContext) PRIMARY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPRIMARY_SYMBOL, 0) +} + +func (s *Alter_actionContext) KEY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserKEY_SYMBOL, 0) +} + +func (s *Alter_actionContext) ALTER_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserALTER_SYMBOL, 0) +} + +func (s *Alter_actionContext) Constraint_enforcement() IConstraint_enforcementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_enforcementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_enforcementContext) +} + +func (s *Alter_actionContext) COLUMN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOLUMN_SYMBOL, 0) +} + +func (s *Alter_actionContext) Table_column_definition() ITable_column_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_column_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_column_definitionContext) +} + +func (s *Alter_actionContext) Column_position() IColumn_positionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_positionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_positionContext) +} + +func (s *Alter_actionContext) Fill_using_expression() IFill_using_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFill_using_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFill_using_expressionContext) +} + +func (s *Alter_actionContext) RENAME_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRENAME_SYMBOL, 0) +} + +func (s *Alter_actionContext) TO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTO_SYMBOL, 0) +} + +func (s *Alter_actionContext) DATA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDATA_SYMBOL, 0) +} + +func (s *Alter_actionContext) TYPE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTYPE_SYMBOL, 0) +} + +func (s *Alter_actionContext) Field_schema() IField_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IField_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IField_schemaContext) +} + +func (s *Alter_actionContext) DEFAULT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDEFAULT_SYMBOL, 0) +} + +func (s *Alter_actionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Alter_actionContext) NOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNOT_SYMBOL, 0) +} + +func (s *Alter_actionContext) NULL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNULL_SYMBOL, 0) +} + +func (s *Alter_actionContext) GENERATED_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserGENERATED_SYMBOL, 0) +} + +func (s *Alter_actionContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Alter_actionContext) Collate_clause() ICollate_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollate_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollate_clauseContext) +} + +func (s *Alter_actionContext) ROW_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserROW_SYMBOL, 0) +} + +func (s *Alter_actionContext) DELETION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDELETION_SYMBOL, 0) +} + +func (s *Alter_actionContext) POLICY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPOLICY_SYMBOL, 0) +} + +func (s *Alter_actionContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Alter_actionContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Alter_actionContext) REPLACE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREPLACE_SYMBOL, 0) +} + +func (s *Alter_actionContext) Generic_sub_entity_type() IGeneric_sub_entity_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneric_sub_entity_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneric_sub_entity_typeContext) +} + +func (s *Alter_actionContext) Alter_action() IAlter_actionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_actionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_actionContext) +} + +func (s *Alter_actionContext) Spanner_alter_column_action() ISpanner_alter_column_actionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpanner_alter_column_actionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISpanner_alter_column_actionContext) +} + +func (s *Alter_actionContext) Spanner_set_on_delete_action() ISpanner_set_on_delete_actionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpanner_set_on_delete_actionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISpanner_set_on_delete_actionContext) +} + +func (s *Alter_actionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_actionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterAlter_action(s) + } +} + +func (s *Alter_actionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitAlter_action(s) + } +} + +func (s *Alter_actionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitAlter_action(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Alter_action() (localctx IAlter_actionContext) { + localctx = NewAlter_actionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 588, GoogleSQLParserRULE_alter_action) + var _la int + + p.SetState(4147) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 481, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3954) + p.Match(GoogleSQLParserSET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3955) + p.Match(GoogleSQLParserOPTIONS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3956) + p.Options_list() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3957) + p.Match(GoogleSQLParserSET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3958) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3959) + p.Generic_entity_body() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3960) + p.Match(GoogleSQLParserADD_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3961) + p.Table_constraint_spec() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3962) + p.Match(GoogleSQLParserADD_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3963) + p.Primary_key_spec() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3964) + p.Match(GoogleSQLParserADD_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3965) + p.Match(GoogleSQLParserCONSTRAINT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3967) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(3966) + p.Opt_if_not_exists() + } + + } + { + p.SetState(3969) + p.Identifier() + } + { + p.SetState(3970) + p.Primary_key_or_table_constraint_spec() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3972) + p.Match(GoogleSQLParserDROP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3973) + p.Match(GoogleSQLParserCONSTRAINT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3975) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(3974) + p.Opt_if_exists() + } + + } + { + p.SetState(3977) + p.Identifier() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(3978) + p.Match(GoogleSQLParserDROP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3979) + p.Match(GoogleSQLParserPRIMARY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3980) + p.Match(GoogleSQLParserKEY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3982) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(3981) + p.Opt_if_exists() + } + + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(3984) + p.Match(GoogleSQLParserALTER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3985) + p.Match(GoogleSQLParserCONSTRAINT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3987) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(3986) + p.Opt_if_exists() + } + + } + { + p.SetState(3989) + p.Identifier() + } + { + p.SetState(3990) + p.Constraint_enforcement() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(3992) + p.Match(GoogleSQLParserALTER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3993) + p.Match(GoogleSQLParserCONSTRAINT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3995) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(3994) + p.Opt_if_exists() + } + + } + { + p.SetState(3997) + p.Identifier() + } + { + p.SetState(3998) + p.Match(GoogleSQLParserSET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3999) + p.Match(GoogleSQLParserOPTIONS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4000) + p.Options_list() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(4002) + p.Match(GoogleSQLParserADD_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4003) + p.Match(GoogleSQLParserCOLUMN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4005) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(4004) + p.Opt_if_not_exists() + } + + } + { + p.SetState(4007) + p.Table_column_definition() + } + p.SetState(4009) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserPRECEDING_SYMBOL || _la == GoogleSQLParserFOLLOWING_SYMBOL { + { + p.SetState(4008) + p.Column_position() + } + + } + p.SetState(4012) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserFILL_SYMBOL { + { + p.SetState(4011) + p.Fill_using_expression() + } + + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(4014) + p.Match(GoogleSQLParserDROP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4015) + p.Match(GoogleSQLParserCOLUMN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4017) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(4016) + p.Opt_if_exists() + } + + } + { + p.SetState(4019) + p.Identifier() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(4020) + p.Match(GoogleSQLParserRENAME_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4021) + p.Match(GoogleSQLParserCOLUMN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4023) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(4022) + p.Opt_if_exists() + } + + } + { + p.SetState(4025) + p.Identifier() + } + { + p.SetState(4026) + p.Match(GoogleSQLParserTO_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4027) + p.Identifier() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(4029) + p.Match(GoogleSQLParserALTER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4030) + p.Match(GoogleSQLParserCOLUMN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4032) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(4031) + p.Opt_if_exists() + } + + } + { + p.SetState(4034) + p.Identifier() + } + { + p.SetState(4035) + p.Match(GoogleSQLParserSET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4036) + p.Match(GoogleSQLParserDATA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4037) + p.Match(GoogleSQLParserTYPE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4038) + p.Field_schema() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(4040) + p.Match(GoogleSQLParserALTER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4041) + p.Match(GoogleSQLParserCOLUMN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4043) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(4042) + p.Opt_if_exists() + } + + } + { + p.SetState(4045) + p.Identifier() + } + { + p.SetState(4046) + p.Match(GoogleSQLParserSET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4047) + p.Match(GoogleSQLParserOPTIONS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4048) + p.Options_list() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(4050) + p.Match(GoogleSQLParserALTER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4051) + p.Match(GoogleSQLParserCOLUMN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4053) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(4052) + p.Opt_if_exists() + } + + } + { + p.SetState(4055) + p.Identifier() + } + { + p.SetState(4056) + p.Match(GoogleSQLParserSET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4057) + p.Match(GoogleSQLParserDEFAULT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4058) + p.expression(0) + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(4060) + p.Match(GoogleSQLParserALTER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4061) + p.Match(GoogleSQLParserCOLUMN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4063) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(4062) + p.Opt_if_exists() + } + + } + { + p.SetState(4065) + p.Identifier() + } + { + p.SetState(4066) + p.Match(GoogleSQLParserDROP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4067) + p.Match(GoogleSQLParserDEFAULT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(4069) + p.Match(GoogleSQLParserALTER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4070) + p.Match(GoogleSQLParserCOLUMN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4072) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(4071) + p.Opt_if_exists() + } + + } + { + p.SetState(4074) + p.Identifier() + } + { + p.SetState(4075) + p.Match(GoogleSQLParserDROP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4076) + p.Match(GoogleSQLParserNOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4077) + p.Match(GoogleSQLParserNULL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(4079) + p.Match(GoogleSQLParserALTER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4080) + p.Match(GoogleSQLParserCOLUMN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4082) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(4081) + p.Opt_if_exists() + } + + } + { + p.SetState(4084) + p.Identifier() + } + { + p.SetState(4085) + p.Match(GoogleSQLParserDROP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4086) + p.Match(GoogleSQLParserGENERATED_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(4088) + p.Match(GoogleSQLParserRENAME_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4089) + p.Match(GoogleSQLParserTO_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4090) + p.Path_expression() + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(4091) + p.Match(GoogleSQLParserSET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4092) + p.Match(GoogleSQLParserDEFAULT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4093) + p.Collate_clause() + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(4094) + p.Match(GoogleSQLParserADD_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4095) + p.Match(GoogleSQLParserROW_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4096) + p.Match(GoogleSQLParserDELETION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4097) + p.Match(GoogleSQLParserPOLICY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4099) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(4098) + p.Opt_if_not_exists() + } + + } + { + p.SetState(4101) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4102) + p.expression(0) + } + { + p.SetState(4103) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(4105) + p.Match(GoogleSQLParserREPLACE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4106) + p.Match(GoogleSQLParserROW_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4107) + p.Match(GoogleSQLParserDELETION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4108) + p.Match(GoogleSQLParserPOLICY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4110) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(4109) + p.Opt_if_exists() + } + + } + { + p.SetState(4112) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4113) + p.expression(0) + } + { + p.SetState(4114) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(4116) + p.Match(GoogleSQLParserDROP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4117) + p.Match(GoogleSQLParserROW_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4118) + p.Match(GoogleSQLParserDELETION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4119) + p.Match(GoogleSQLParserPOLICY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4121) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(4120) + p.Opt_if_exists() + } + + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(4123) + p.Match(GoogleSQLParserALTER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4124) + p.Generic_sub_entity_type() + } + p.SetState(4126) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(4125) + p.Opt_if_exists() + } + + } + { + p.SetState(4128) + p.Identifier() + } + { + p.SetState(4129) + p.Alter_action() + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(4131) + p.Match(GoogleSQLParserADD_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4132) + p.Generic_sub_entity_type() + } + p.SetState(4134) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(4133) + p.Opt_if_not_exists() + } + + } + { + p.SetState(4136) + p.Identifier() + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(4138) + p.Match(GoogleSQLParserDROP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4139) + p.Generic_sub_entity_type() + } + p.SetState(4141) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(4140) + p.Opt_if_exists() + } + + } + { + p.SetState(4143) + p.Identifier() + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(4145) + p.Spanner_alter_column_action() + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(4146) + p.Spanner_set_on_delete_action() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISpanner_set_on_delete_actionContext is an interface to support dynamic dispatch. +type ISpanner_set_on_delete_actionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET_SYMBOL() antlr.TerminalNode + ON_SYMBOL() antlr.TerminalNode + DELETE_SYMBOL() antlr.TerminalNode + Foreign_key_action() IForeign_key_actionContext + + // IsSpanner_set_on_delete_actionContext differentiates from other interfaces. + IsSpanner_set_on_delete_actionContext() +} + +type Spanner_set_on_delete_actionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySpanner_set_on_delete_actionContext() *Spanner_set_on_delete_actionContext { + var p = new(Spanner_set_on_delete_actionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_spanner_set_on_delete_action + return p +} + +func InitEmptySpanner_set_on_delete_actionContext(p *Spanner_set_on_delete_actionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_spanner_set_on_delete_action +} + +func (*Spanner_set_on_delete_actionContext) IsSpanner_set_on_delete_actionContext() {} + +func NewSpanner_set_on_delete_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Spanner_set_on_delete_actionContext { + var p = new(Spanner_set_on_delete_actionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_spanner_set_on_delete_action + + return p +} + +func (s *Spanner_set_on_delete_actionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Spanner_set_on_delete_actionContext) SET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSET_SYMBOL, 0) +} + +func (s *Spanner_set_on_delete_actionContext) ON_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserON_SYMBOL, 0) +} + +func (s *Spanner_set_on_delete_actionContext) DELETE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDELETE_SYMBOL, 0) +} + +func (s *Spanner_set_on_delete_actionContext) Foreign_key_action() IForeign_key_actionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForeign_key_actionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForeign_key_actionContext) +} + +func (s *Spanner_set_on_delete_actionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Spanner_set_on_delete_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Spanner_set_on_delete_actionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSpanner_set_on_delete_action(s) + } +} + +func (s *Spanner_set_on_delete_actionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSpanner_set_on_delete_action(s) + } +} + +func (s *Spanner_set_on_delete_actionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSpanner_set_on_delete_action(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Spanner_set_on_delete_action() (localctx ISpanner_set_on_delete_actionContext) { + localctx = NewSpanner_set_on_delete_actionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 590, GoogleSQLParserRULE_spanner_set_on_delete_action) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4149) + p.Match(GoogleSQLParserSET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4150) + p.Match(GoogleSQLParserON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4151) + p.Match(GoogleSQLParserDELETE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4152) + p.Foreign_key_action() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISpanner_alter_column_actionContext is an interface to support dynamic dispatch. +type ISpanner_alter_column_actionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER_SYMBOL() antlr.TerminalNode + COLUMN_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + Column_schema_inner() IColumn_schema_innerContext + Opt_if_exists() IOpt_if_existsContext + Not_null_column_attribute() INot_null_column_attributeContext + Spanner_generated_or_default() ISpanner_generated_or_defaultContext + Opt_options_list() IOpt_options_listContext + + // IsSpanner_alter_column_actionContext differentiates from other interfaces. + IsSpanner_alter_column_actionContext() +} + +type Spanner_alter_column_actionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySpanner_alter_column_actionContext() *Spanner_alter_column_actionContext { + var p = new(Spanner_alter_column_actionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_spanner_alter_column_action + return p +} + +func InitEmptySpanner_alter_column_actionContext(p *Spanner_alter_column_actionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_spanner_alter_column_action +} + +func (*Spanner_alter_column_actionContext) IsSpanner_alter_column_actionContext() {} + +func NewSpanner_alter_column_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Spanner_alter_column_actionContext { + var p = new(Spanner_alter_column_actionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_spanner_alter_column_action + + return p +} + +func (s *Spanner_alter_column_actionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Spanner_alter_column_actionContext) ALTER_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserALTER_SYMBOL, 0) +} + +func (s *Spanner_alter_column_actionContext) COLUMN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOLUMN_SYMBOL, 0) +} + +func (s *Spanner_alter_column_actionContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Spanner_alter_column_actionContext) Column_schema_inner() IColumn_schema_innerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_schema_innerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_schema_innerContext) +} + +func (s *Spanner_alter_column_actionContext) Opt_if_exists() IOpt_if_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_existsContext) +} + +func (s *Spanner_alter_column_actionContext) Not_null_column_attribute() INot_null_column_attributeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INot_null_column_attributeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INot_null_column_attributeContext) +} + +func (s *Spanner_alter_column_actionContext) Spanner_generated_or_default() ISpanner_generated_or_defaultContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpanner_generated_or_defaultContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISpanner_generated_or_defaultContext) +} + +func (s *Spanner_alter_column_actionContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Spanner_alter_column_actionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Spanner_alter_column_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Spanner_alter_column_actionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSpanner_alter_column_action(s) + } +} + +func (s *Spanner_alter_column_actionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSpanner_alter_column_action(s) + } +} + +func (s *Spanner_alter_column_actionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSpanner_alter_column_action(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Spanner_alter_column_action() (localctx ISpanner_alter_column_actionContext) { + localctx = NewSpanner_alter_column_actionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 592, GoogleSQLParserRULE_spanner_alter_column_action) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4154) + p.Match(GoogleSQLParserALTER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4155) + p.Match(GoogleSQLParserCOLUMN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4157) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIF_SYMBOL { + { + p.SetState(4156) + p.Opt_if_exists() + } + + } + { + p.SetState(4159) + p.Identifier() + } + { + p.SetState(4160) + p.Column_schema_inner() + } + p.SetState(4162) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserNOT_SYMBOL { + { + p.SetState(4161) + p.Not_null_column_attribute() + } + + } + p.SetState(4165) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(4164) + p.Spanner_generated_or_default() + } + + } + p.SetState(4168) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(4167) + p.Opt_options_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISpanner_generated_or_defaultContext is an interface to support dynamic dispatch. +type ISpanner_generated_or_defaultContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AS_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + STORED_SYMBOL() antlr.TerminalNode + + // IsSpanner_generated_or_defaultContext differentiates from other interfaces. + IsSpanner_generated_or_defaultContext() +} + +type Spanner_generated_or_defaultContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySpanner_generated_or_defaultContext() *Spanner_generated_or_defaultContext { + var p = new(Spanner_generated_or_defaultContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_spanner_generated_or_default + return p +} + +func InitEmptySpanner_generated_or_defaultContext(p *Spanner_generated_or_defaultContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_spanner_generated_or_default +} + +func (*Spanner_generated_or_defaultContext) IsSpanner_generated_or_defaultContext() {} + +func NewSpanner_generated_or_defaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Spanner_generated_or_defaultContext { + var p = new(Spanner_generated_or_defaultContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_spanner_generated_or_default + + return p +} + +func (s *Spanner_generated_or_defaultContext) GetParser() antlr.Parser { return s.parser } + +func (s *Spanner_generated_or_defaultContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Spanner_generated_or_defaultContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Spanner_generated_or_defaultContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Spanner_generated_or_defaultContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Spanner_generated_or_defaultContext) STORED_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTORED_SYMBOL, 0) +} + +func (s *Spanner_generated_or_defaultContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Spanner_generated_or_defaultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Spanner_generated_or_defaultContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSpanner_generated_or_default(s) + } +} + +func (s *Spanner_generated_or_defaultContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSpanner_generated_or_default(s) + } +} + +func (s *Spanner_generated_or_defaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSpanner_generated_or_default(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Spanner_generated_or_default() (localctx ISpanner_generated_or_defaultContext) { + localctx = NewSpanner_generated_or_defaultContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 594, GoogleSQLParserRULE_spanner_generated_or_default) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4170) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4171) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4172) + p.expression(0) + } + { + p.SetState(4173) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4174) + p.Match(GoogleSQLParserSTORED_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGeneric_sub_entity_typeContext is an interface to support dynamic dispatch. +type IGeneric_sub_entity_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Sub_entity_type_identifier() ISub_entity_type_identifierContext + + // IsGeneric_sub_entity_typeContext differentiates from other interfaces. + IsGeneric_sub_entity_typeContext() +} + +type Generic_sub_entity_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGeneric_sub_entity_typeContext() *Generic_sub_entity_typeContext { + var p = new(Generic_sub_entity_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_generic_sub_entity_type + return p +} + +func InitEmptyGeneric_sub_entity_typeContext(p *Generic_sub_entity_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_generic_sub_entity_type +} + +func (*Generic_sub_entity_typeContext) IsGeneric_sub_entity_typeContext() {} + +func NewGeneric_sub_entity_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generic_sub_entity_typeContext { + var p = new(Generic_sub_entity_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_generic_sub_entity_type + + return p +} + +func (s *Generic_sub_entity_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Generic_sub_entity_typeContext) Sub_entity_type_identifier() ISub_entity_type_identifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISub_entity_type_identifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISub_entity_type_identifierContext) +} + +func (s *Generic_sub_entity_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Generic_sub_entity_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Generic_sub_entity_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGeneric_sub_entity_type(s) + } +} + +func (s *Generic_sub_entity_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGeneric_sub_entity_type(s) + } +} + +func (s *Generic_sub_entity_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGeneric_sub_entity_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Generic_sub_entity_type() (localctx IGeneric_sub_entity_typeContext) { + localctx = NewGeneric_sub_entity_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 596, GoogleSQLParserRULE_generic_sub_entity_type) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4176) + p.Sub_entity_type_identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISub_entity_type_identifierContext is an interface to support dynamic dispatch. +type ISub_entity_type_identifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IDENTIFIER() antlr.TerminalNode + REPLICA_SYMBOL() antlr.TerminalNode + + // IsSub_entity_type_identifierContext differentiates from other interfaces. + IsSub_entity_type_identifierContext() +} + +type Sub_entity_type_identifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySub_entity_type_identifierContext() *Sub_entity_type_identifierContext { + var p = new(Sub_entity_type_identifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_sub_entity_type_identifier + return p +} + +func InitEmptySub_entity_type_identifierContext(p *Sub_entity_type_identifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_sub_entity_type_identifier +} + +func (*Sub_entity_type_identifierContext) IsSub_entity_type_identifierContext() {} + +func NewSub_entity_type_identifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sub_entity_type_identifierContext { + var p = new(Sub_entity_type_identifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_sub_entity_type_identifier + + return p +} + +func (s *Sub_entity_type_identifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sub_entity_type_identifierContext) IDENTIFIER() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIDENTIFIER, 0) +} + +func (s *Sub_entity_type_identifierContext) REPLICA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREPLICA_SYMBOL, 0) +} + +func (s *Sub_entity_type_identifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sub_entity_type_identifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sub_entity_type_identifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSub_entity_type_identifier(s) + } +} + +func (s *Sub_entity_type_identifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSub_entity_type_identifier(s) + } +} + +func (s *Sub_entity_type_identifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSub_entity_type_identifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Sub_entity_type_identifier() (localctx ISub_entity_type_identifierContext) { + localctx = NewSub_entity_type_identifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 598, GoogleSQLParserRULE_sub_entity_type_identifier) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4178) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserREPLICA_SYMBOL || _la == GoogleSQLParserIDENTIFIER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFill_using_expressionContext is an interface to support dynamic dispatch. +type IFill_using_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FILL_SYMBOL() antlr.TerminalNode + USING_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + + // IsFill_using_expressionContext differentiates from other interfaces. + IsFill_using_expressionContext() +} + +type Fill_using_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFill_using_expressionContext() *Fill_using_expressionContext { + var p = new(Fill_using_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_fill_using_expression + return p +} + +func InitEmptyFill_using_expressionContext(p *Fill_using_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_fill_using_expression +} + +func (*Fill_using_expressionContext) IsFill_using_expressionContext() {} + +func NewFill_using_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Fill_using_expressionContext { + var p = new(Fill_using_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_fill_using_expression + + return p +} + +func (s *Fill_using_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Fill_using_expressionContext) FILL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFILL_SYMBOL, 0) +} + +func (s *Fill_using_expressionContext) USING_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUSING_SYMBOL, 0) +} + +func (s *Fill_using_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Fill_using_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Fill_using_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Fill_using_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterFill_using_expression(s) + } +} + +func (s *Fill_using_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitFill_using_expression(s) + } +} + +func (s *Fill_using_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitFill_using_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Fill_using_expression() (localctx IFill_using_expressionContext) { + localctx = NewFill_using_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 600, GoogleSQLParserRULE_fill_using_expression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4180) + p.Match(GoogleSQLParserFILL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4181) + p.Match(GoogleSQLParserUSING_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4182) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_positionContext is an interface to support dynamic dispatch. +type IColumn_positionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PRECEDING_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + FOLLOWING_SYMBOL() antlr.TerminalNode + + // IsColumn_positionContext differentiates from other interfaces. + IsColumn_positionContext() +} + +type Column_positionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_positionContext() *Column_positionContext { + var p = new(Column_positionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_column_position + return p +} + +func InitEmptyColumn_positionContext(p *Column_positionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_column_position +} + +func (*Column_positionContext) IsColumn_positionContext() {} + +func NewColumn_positionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_positionContext { + var p = new(Column_positionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_column_position + + return p +} + +func (s *Column_positionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_positionContext) PRECEDING_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPRECEDING_SYMBOL, 0) +} + +func (s *Column_positionContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Column_positionContext) FOLLOWING_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFOLLOWING_SYMBOL, 0) +} + +func (s *Column_positionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_positionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_positionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterColumn_position(s) + } +} + +func (s *Column_positionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitColumn_position(s) + } +} + +func (s *Column_positionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitColumn_position(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Column_position() (localctx IColumn_positionContext) { + localctx = NewColumn_positionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 602, GoogleSQLParserRULE_column_position) + p.SetState(4188) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserPRECEDING_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4184) + p.Match(GoogleSQLParserPRECEDING_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4185) + p.Identifier() + } + + case GoogleSQLParserFOLLOWING_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4186) + p.Match(GoogleSQLParserFOLLOWING_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4187) + p.Identifier() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_column_definitionContext is an interface to support dynamic dispatch. +type ITable_column_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Table_column_schema() ITable_column_schemaContext + Column_attributes() IColumn_attributesContext + Opt_options_list() IOpt_options_listContext + + // IsTable_column_definitionContext differentiates from other interfaces. + IsTable_column_definitionContext() +} + +type Table_column_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_column_definitionContext() *Table_column_definitionContext { + var p = new(Table_column_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_column_definition + return p +} + +func InitEmptyTable_column_definitionContext(p *Table_column_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_column_definition +} + +func (*Table_column_definitionContext) IsTable_column_definitionContext() {} + +func NewTable_column_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_column_definitionContext { + var p = new(Table_column_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_table_column_definition + + return p +} + +func (s *Table_column_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_column_definitionContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Table_column_definitionContext) Table_column_schema() ITable_column_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_column_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_column_schemaContext) +} + +func (s *Table_column_definitionContext) Column_attributes() IColumn_attributesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_attributesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_attributesContext) +} + +func (s *Table_column_definitionContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Table_column_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_column_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_column_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTable_column_definition(s) + } +} + +func (s *Table_column_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTable_column_definition(s) + } +} + +func (s *Table_column_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTable_column_definition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Table_column_definition() (localctx ITable_column_definitionContext) { + localctx = NewTable_column_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 604, GoogleSQLParserRULE_table_column_definition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4190) + p.Identifier() + } + { + p.SetState(4191) + p.Table_column_schema() + } + p.SetState(4193) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserNOT_SYMBOL || _la == GoogleSQLParserCONSTRAINT_SYMBOL || ((int64((_la-182)) & ^0x3f) == 0 && ((int64(1)<<(_la-182))&4512395720392705) != 0) { + { + p.SetState(4192) + p.Column_attributes() + } + + } + p.SetState(4196) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(4195) + p.Opt_options_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_attributesContext is an interface to support dynamic dispatch. +type IColumn_attributesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllColumn_attribute() []IColumn_attributeContext + Column_attribute(i int) IColumn_attributeContext + Constraint_enforcement() IConstraint_enforcementContext + + // IsColumn_attributesContext differentiates from other interfaces. + IsColumn_attributesContext() +} + +type Column_attributesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_attributesContext() *Column_attributesContext { + var p = new(Column_attributesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_column_attributes + return p +} + +func InitEmptyColumn_attributesContext(p *Column_attributesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_column_attributes +} + +func (*Column_attributesContext) IsColumn_attributesContext() {} + +func NewColumn_attributesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_attributesContext { + var p = new(Column_attributesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_column_attributes + + return p +} + +func (s *Column_attributesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_attributesContext) AllColumn_attribute() []IColumn_attributeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_attributeContext); ok { + len++ + } + } + + tst := make([]IColumn_attributeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_attributeContext); ok { + tst[i] = t.(IColumn_attributeContext) + i++ + } + } + + return tst +} + +func (s *Column_attributesContext) Column_attribute(i int) IColumn_attributeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_attributeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_attributeContext) +} + +func (s *Column_attributesContext) Constraint_enforcement() IConstraint_enforcementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_enforcementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_enforcementContext) +} + +func (s *Column_attributesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_attributesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_attributesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterColumn_attributes(s) + } +} + +func (s *Column_attributesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitColumn_attributes(s) + } +} + +func (s *Column_attributesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitColumn_attributes(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Column_attributes() (localctx IColumn_attributesContext) { + localctx = NewColumn_attributesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 606, GoogleSQLParserRULE_column_attributes) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4199) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(4198) + p.Column_attribute() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(4201) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 489, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(4204) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserNOT_SYMBOL || _la == GoogleSQLParserENFORCED_SYMBOL { + { + p.SetState(4203) + p.Constraint_enforcement() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_attributeContext is an interface to support dynamic dispatch. +type IColumn_attributeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Primary_key_column_attribute() IPrimary_key_column_attributeContext + Foreign_key_column_attribute() IForeign_key_column_attributeContext + Hidden_column_attribute() IHidden_column_attributeContext + Not_null_column_attribute() INot_null_column_attributeContext + + // IsColumn_attributeContext differentiates from other interfaces. + IsColumn_attributeContext() +} + +type Column_attributeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_attributeContext() *Column_attributeContext { + var p = new(Column_attributeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_column_attribute + return p +} + +func InitEmptyColumn_attributeContext(p *Column_attributeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_column_attribute +} + +func (*Column_attributeContext) IsColumn_attributeContext() {} + +func NewColumn_attributeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_attributeContext { + var p = new(Column_attributeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_column_attribute + + return p +} + +func (s *Column_attributeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_attributeContext) Primary_key_column_attribute() IPrimary_key_column_attributeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimary_key_column_attributeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimary_key_column_attributeContext) +} + +func (s *Column_attributeContext) Foreign_key_column_attribute() IForeign_key_column_attributeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForeign_key_column_attributeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForeign_key_column_attributeContext) +} + +func (s *Column_attributeContext) Hidden_column_attribute() IHidden_column_attributeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHidden_column_attributeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHidden_column_attributeContext) +} + +func (s *Column_attributeContext) Not_null_column_attribute() INot_null_column_attributeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INot_null_column_attributeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INot_null_column_attributeContext) +} + +func (s *Column_attributeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_attributeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_attributeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterColumn_attribute(s) + } +} + +func (s *Column_attributeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitColumn_attribute(s) + } +} + +func (s *Column_attributeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitColumn_attribute(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Column_attribute() (localctx IColumn_attributeContext) { + localctx = NewColumn_attributeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 608, GoogleSQLParserRULE_column_attribute) + p.SetState(4210) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserPRIMARY_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4206) + p.Primary_key_column_attribute() + } + + case GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4207) + p.Foreign_key_column_attribute() + } + + case GoogleSQLParserHIDDEN_SYMBOL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4208) + p.Hidden_column_attribute() + } + + case GoogleSQLParserNOT_SYMBOL: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4209) + p.Not_null_column_attribute() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrimary_key_column_attributeContext is an interface to support dynamic dispatch. +type IPrimary_key_column_attributeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PRIMARY_SYMBOL() antlr.TerminalNode + KEY_SYMBOL() antlr.TerminalNode + + // IsPrimary_key_column_attributeContext differentiates from other interfaces. + IsPrimary_key_column_attributeContext() +} + +type Primary_key_column_attributeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrimary_key_column_attributeContext() *Primary_key_column_attributeContext { + var p = new(Primary_key_column_attributeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_primary_key_column_attribute + return p +} + +func InitEmptyPrimary_key_column_attributeContext(p *Primary_key_column_attributeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_primary_key_column_attribute +} + +func (*Primary_key_column_attributeContext) IsPrimary_key_column_attributeContext() {} + +func NewPrimary_key_column_attributeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Primary_key_column_attributeContext { + var p = new(Primary_key_column_attributeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_primary_key_column_attribute + + return p +} + +func (s *Primary_key_column_attributeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Primary_key_column_attributeContext) PRIMARY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPRIMARY_SYMBOL, 0) +} + +func (s *Primary_key_column_attributeContext) KEY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserKEY_SYMBOL, 0) +} + +func (s *Primary_key_column_attributeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Primary_key_column_attributeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Primary_key_column_attributeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPrimary_key_column_attribute(s) + } +} + +func (s *Primary_key_column_attributeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPrimary_key_column_attribute(s) + } +} + +func (s *Primary_key_column_attributeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPrimary_key_column_attribute(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Primary_key_column_attribute() (localctx IPrimary_key_column_attributeContext) { + localctx = NewPrimary_key_column_attributeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 610, GoogleSQLParserRULE_primary_key_column_attribute) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4212) + p.Match(GoogleSQLParserPRIMARY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4213) + p.Match(GoogleSQLParserKEY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IForeign_key_column_attributeContext is an interface to support dynamic dispatch. +type IForeign_key_column_attributeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Foreign_key_reference() IForeign_key_referenceContext + Opt_constraint_identity() IOpt_constraint_identityContext + + // IsForeign_key_column_attributeContext differentiates from other interfaces. + IsForeign_key_column_attributeContext() +} + +type Foreign_key_column_attributeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyForeign_key_column_attributeContext() *Foreign_key_column_attributeContext { + var p = new(Foreign_key_column_attributeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_foreign_key_column_attribute + return p +} + +func InitEmptyForeign_key_column_attributeContext(p *Foreign_key_column_attributeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_foreign_key_column_attribute +} + +func (*Foreign_key_column_attributeContext) IsForeign_key_column_attributeContext() {} + +func NewForeign_key_column_attributeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Foreign_key_column_attributeContext { + var p = new(Foreign_key_column_attributeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_foreign_key_column_attribute + + return p +} + +func (s *Foreign_key_column_attributeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Foreign_key_column_attributeContext) Foreign_key_reference() IForeign_key_referenceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForeign_key_referenceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForeign_key_referenceContext) +} + +func (s *Foreign_key_column_attributeContext) Opt_constraint_identity() IOpt_constraint_identityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_constraint_identityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_constraint_identityContext) +} + +func (s *Foreign_key_column_attributeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Foreign_key_column_attributeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Foreign_key_column_attributeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterForeign_key_column_attribute(s) + } +} + +func (s *Foreign_key_column_attributeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitForeign_key_column_attribute(s) + } +} + +func (s *Foreign_key_column_attributeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitForeign_key_column_attribute(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Foreign_key_column_attribute() (localctx IForeign_key_column_attributeContext) { + localctx = NewForeign_key_column_attributeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 612, GoogleSQLParserRULE_foreign_key_column_attribute) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4216) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCONSTRAINT_SYMBOL { + { + p.SetState(4215) + p.Opt_constraint_identity() + } + + } + { + p.SetState(4218) + p.Foreign_key_reference() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHidden_column_attributeContext is an interface to support dynamic dispatch. +type IHidden_column_attributeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HIDDEN_SYMBOL() antlr.TerminalNode + + // IsHidden_column_attributeContext differentiates from other interfaces. + IsHidden_column_attributeContext() +} + +type Hidden_column_attributeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHidden_column_attributeContext() *Hidden_column_attributeContext { + var p = new(Hidden_column_attributeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_hidden_column_attribute + return p +} + +func InitEmptyHidden_column_attributeContext(p *Hidden_column_attributeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_hidden_column_attribute +} + +func (*Hidden_column_attributeContext) IsHidden_column_attributeContext() {} + +func NewHidden_column_attributeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hidden_column_attributeContext { + var p = new(Hidden_column_attributeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_hidden_column_attribute + + return p +} + +func (s *Hidden_column_attributeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hidden_column_attributeContext) HIDDEN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserHIDDEN_SYMBOL, 0) +} + +func (s *Hidden_column_attributeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hidden_column_attributeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hidden_column_attributeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterHidden_column_attribute(s) + } +} + +func (s *Hidden_column_attributeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitHidden_column_attribute(s) + } +} + +func (s *Hidden_column_attributeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitHidden_column_attribute(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Hidden_column_attribute() (localctx IHidden_column_attributeContext) { + localctx = NewHidden_column_attributeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 614, GoogleSQLParserRULE_hidden_column_attribute) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4220) + p.Match(GoogleSQLParserHIDDEN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_constraint_identityContext is an interface to support dynamic dispatch. +type IOpt_constraint_identityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONSTRAINT_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsOpt_constraint_identityContext differentiates from other interfaces. + IsOpt_constraint_identityContext() +} + +type Opt_constraint_identityContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_constraint_identityContext() *Opt_constraint_identityContext { + var p = new(Opt_constraint_identityContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_constraint_identity + return p +} + +func InitEmptyOpt_constraint_identityContext(p *Opt_constraint_identityContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_constraint_identity +} + +func (*Opt_constraint_identityContext) IsOpt_constraint_identityContext() {} + +func NewOpt_constraint_identityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_constraint_identityContext { + var p = new(Opt_constraint_identityContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_constraint_identity + + return p +} + +func (s *Opt_constraint_identityContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_constraint_identityContext) CONSTRAINT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCONSTRAINT_SYMBOL, 0) +} + +func (s *Opt_constraint_identityContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Opt_constraint_identityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_constraint_identityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_constraint_identityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_constraint_identity(s) + } +} + +func (s *Opt_constraint_identityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_constraint_identity(s) + } +} + +func (s *Opt_constraint_identityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_constraint_identity(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_constraint_identity() (localctx IOpt_constraint_identityContext) { + localctx = NewOpt_constraint_identityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 616, GoogleSQLParserRULE_opt_constraint_identity) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4222) + p.Match(GoogleSQLParserCONSTRAINT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4223) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_column_schemaContext is an interface to support dynamic dispatch. +type ITable_column_schemaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_schema_inner() IColumn_schema_innerContext + Collate_clause() ICollate_clauseContext + Opt_column_info() IOpt_column_infoContext + Generated_column_info() IGenerated_column_infoContext + + // IsTable_column_schemaContext differentiates from other interfaces. + IsTable_column_schemaContext() +} + +type Table_column_schemaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_column_schemaContext() *Table_column_schemaContext { + var p = new(Table_column_schemaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_column_schema + return p +} + +func InitEmptyTable_column_schemaContext(p *Table_column_schemaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_column_schema +} + +func (*Table_column_schemaContext) IsTable_column_schemaContext() {} + +func NewTable_column_schemaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_column_schemaContext { + var p = new(Table_column_schemaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_table_column_schema + + return p +} + +func (s *Table_column_schemaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_column_schemaContext) Column_schema_inner() IColumn_schema_innerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_schema_innerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_schema_innerContext) +} + +func (s *Table_column_schemaContext) Collate_clause() ICollate_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollate_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollate_clauseContext) +} + +func (s *Table_column_schemaContext) Opt_column_info() IOpt_column_infoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_column_infoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_column_infoContext) +} + +func (s *Table_column_schemaContext) Generated_column_info() IGenerated_column_infoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGenerated_column_infoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGenerated_column_infoContext) +} + +func (s *Table_column_schemaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_column_schemaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_column_schemaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTable_column_schema(s) + } +} + +func (s *Table_column_schemaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTable_column_schema(s) + } +} + +func (s *Table_column_schemaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTable_column_schema(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Table_column_schema() (localctx ITable_column_schemaContext) { + localctx = NewTable_column_schemaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 618, GoogleSQLParserRULE_table_column_schema) + var _la int + + p.SetState(4233) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 495, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4225) + p.Column_schema_inner() + } + p.SetState(4227) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCOLLATE_SYMBOL { + { + p.SetState(4226) + p.Collate_clause() + } + + } + p.SetState(4230) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL || _la == GoogleSQLParserGENERATED_SYMBOL || _la == GoogleSQLParserDEFAULT_SYMBOL { + { + p.SetState(4229) + p.Opt_column_info() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4232) + p.Generated_column_info() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_column_infoContext is an interface to support dynamic dispatch. +type IOpt_column_infoContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Generated_column_info() IGenerated_column_infoContext + Invalid_default_column() IInvalid_default_columnContext + Default_column_info() IDefault_column_infoContext + Invalid_generated_column() IInvalid_generated_columnContext + + // IsOpt_column_infoContext differentiates from other interfaces. + IsOpt_column_infoContext() +} + +type Opt_column_infoContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_column_infoContext() *Opt_column_infoContext { + var p = new(Opt_column_infoContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_column_info + return p +} + +func InitEmptyOpt_column_infoContext(p *Opt_column_infoContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_column_info +} + +func (*Opt_column_infoContext) IsOpt_column_infoContext() {} + +func NewOpt_column_infoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_column_infoContext { + var p = new(Opt_column_infoContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_column_info + + return p +} + +func (s *Opt_column_infoContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_column_infoContext) Generated_column_info() IGenerated_column_infoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGenerated_column_infoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGenerated_column_infoContext) +} + +func (s *Opt_column_infoContext) Invalid_default_column() IInvalid_default_columnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInvalid_default_columnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInvalid_default_columnContext) +} + +func (s *Opt_column_infoContext) Default_column_info() IDefault_column_infoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_column_infoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_column_infoContext) +} + +func (s *Opt_column_infoContext) Invalid_generated_column() IInvalid_generated_columnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInvalid_generated_columnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInvalid_generated_columnContext) +} + +func (s *Opt_column_infoContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_column_infoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_column_infoContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_column_info(s) + } +} + +func (s *Opt_column_infoContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_column_info(s) + } +} + +func (s *Opt_column_infoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_column_info(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_column_info() (localctx IOpt_column_infoContext) { + localctx = NewOpt_column_infoContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 620, GoogleSQLParserRULE_opt_column_info) + var _la int + + p.SetState(4247) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserAS_SYMBOL, GoogleSQLParserGENERATED_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4235) + p.Generated_column_info() + } + p.SetState(4237) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserDEFAULT_SYMBOL { + { + p.SetState(4236) + p.Invalid_default_column() + } + + } + + if localctx.Invalid_default_column() != nil { + p.NotifyErrorListeners("Syntax error: \"DEFAULT\" and \"GENERATED ALWAYS AS\" clauses must not be both provided for the column", nil, nil) + } + + case GoogleSQLParserDEFAULT_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4241) + p.Default_column_info() + } + p.SetState(4243) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL || _la == GoogleSQLParserGENERATED_SYMBOL { + { + p.SetState(4242) + p.Invalid_generated_column() + } + + } + + if localctx.Invalid_generated_column() != nil { + p.NotifyErrorListeners("Syntax error: \"DEFAULT\" and \"GENERATED ALWAYS AS\" clauses must not be both provided for the column", nil, nil) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInvalid_generated_columnContext is an interface to support dynamic dispatch. +type IInvalid_generated_columnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Generated_column_info() IGenerated_column_infoContext + + // IsInvalid_generated_columnContext differentiates from other interfaces. + IsInvalid_generated_columnContext() +} + +type Invalid_generated_columnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInvalid_generated_columnContext() *Invalid_generated_columnContext { + var p = new(Invalid_generated_columnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_invalid_generated_column + return p +} + +func InitEmptyInvalid_generated_columnContext(p *Invalid_generated_columnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_invalid_generated_column +} + +func (*Invalid_generated_columnContext) IsInvalid_generated_columnContext() {} + +func NewInvalid_generated_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Invalid_generated_columnContext { + var p = new(Invalid_generated_columnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_invalid_generated_column + + return p +} + +func (s *Invalid_generated_columnContext) GetParser() antlr.Parser { return s.parser } + +func (s *Invalid_generated_columnContext) Generated_column_info() IGenerated_column_infoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGenerated_column_infoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGenerated_column_infoContext) +} + +func (s *Invalid_generated_columnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Invalid_generated_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Invalid_generated_columnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterInvalid_generated_column(s) + } +} + +func (s *Invalid_generated_columnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitInvalid_generated_column(s) + } +} + +func (s *Invalid_generated_columnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitInvalid_generated_column(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Invalid_generated_column() (localctx IInvalid_generated_columnContext) { + localctx = NewInvalid_generated_columnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 622, GoogleSQLParserRULE_invalid_generated_column) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4249) + p.Generated_column_info() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInvalid_default_columnContext is an interface to support dynamic dispatch. +type IInvalid_default_columnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Default_column_info() IDefault_column_infoContext + + // IsInvalid_default_columnContext differentiates from other interfaces. + IsInvalid_default_columnContext() +} + +type Invalid_default_columnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInvalid_default_columnContext() *Invalid_default_columnContext { + var p = new(Invalid_default_columnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_invalid_default_column + return p +} + +func InitEmptyInvalid_default_columnContext(p *Invalid_default_columnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_invalid_default_column +} + +func (*Invalid_default_columnContext) IsInvalid_default_columnContext() {} + +func NewInvalid_default_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Invalid_default_columnContext { + var p = new(Invalid_default_columnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_invalid_default_column + + return p +} + +func (s *Invalid_default_columnContext) GetParser() antlr.Parser { return s.parser } + +func (s *Invalid_default_columnContext) Default_column_info() IDefault_column_infoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_column_infoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_column_infoContext) +} + +func (s *Invalid_default_columnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Invalid_default_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Invalid_default_columnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterInvalid_default_column(s) + } +} + +func (s *Invalid_default_columnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitInvalid_default_column(s) + } +} + +func (s *Invalid_default_columnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitInvalid_default_column(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Invalid_default_column() (localctx IInvalid_default_columnContext) { + localctx = NewInvalid_default_columnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 624, GoogleSQLParserRULE_invalid_default_column) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4251) + p.Default_column_info() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDefault_column_infoContext is an interface to support dynamic dispatch. +type IDefault_column_infoContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + + // IsDefault_column_infoContext differentiates from other interfaces. + IsDefault_column_infoContext() +} + +type Default_column_infoContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_column_infoContext() *Default_column_infoContext { + var p = new(Default_column_infoContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_default_column_info + return p +} + +func InitEmptyDefault_column_infoContext(p *Default_column_infoContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_default_column_info +} + +func (*Default_column_infoContext) IsDefault_column_infoContext() {} + +func NewDefault_column_infoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_column_infoContext { + var p = new(Default_column_infoContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_default_column_info + + return p +} + +func (s *Default_column_infoContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_column_infoContext) DEFAULT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDEFAULT_SYMBOL, 0) +} + +func (s *Default_column_infoContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Default_column_infoContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_column_infoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_column_infoContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterDefault_column_info(s) + } +} + +func (s *Default_column_infoContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitDefault_column_info(s) + } +} + +func (s *Default_column_infoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitDefault_column_info(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Default_column_info() (localctx IDefault_column_infoContext) { + localctx = NewDefault_column_infoContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 626, GoogleSQLParserRULE_default_column_info) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4253) + p.Match(GoogleSQLParserDEFAULT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4254) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGenerated_column_infoContext is an interface to support dynamic dispatch. +type IGenerated_column_infoContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Generated_mode() IGenerated_modeContext + LR_BRACKET_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + Stored_mode() IStored_modeContext + Identity_column_info() IIdentity_column_infoContext + + // IsGenerated_column_infoContext differentiates from other interfaces. + IsGenerated_column_infoContext() +} + +type Generated_column_infoContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGenerated_column_infoContext() *Generated_column_infoContext { + var p = new(Generated_column_infoContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_generated_column_info + return p +} + +func InitEmptyGenerated_column_infoContext(p *Generated_column_infoContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_generated_column_info +} + +func (*Generated_column_infoContext) IsGenerated_column_infoContext() {} + +func NewGenerated_column_infoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generated_column_infoContext { + var p = new(Generated_column_infoContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_generated_column_info + + return p +} + +func (s *Generated_column_infoContext) GetParser() antlr.Parser { return s.parser } + +func (s *Generated_column_infoContext) Generated_mode() IGenerated_modeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGenerated_modeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGenerated_modeContext) +} + +func (s *Generated_column_infoContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Generated_column_infoContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Generated_column_infoContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Generated_column_infoContext) Stored_mode() IStored_modeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStored_modeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStored_modeContext) +} + +func (s *Generated_column_infoContext) Identity_column_info() IIdentity_column_infoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentity_column_infoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentity_column_infoContext) +} + +func (s *Generated_column_infoContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Generated_column_infoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Generated_column_infoContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGenerated_column_info(s) + } +} + +func (s *Generated_column_infoContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGenerated_column_info(s) + } +} + +func (s *Generated_column_infoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGenerated_column_info(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Generated_column_info() (localctx IGenerated_column_infoContext) { + localctx = NewGenerated_column_infoContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 628, GoogleSQLParserRULE_generated_column_info) + var _la int + + p.SetState(4266) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 500, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4256) + p.Generated_mode() + } + { + p.SetState(4257) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4258) + p.expression(0) + } + { + p.SetState(4259) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4261) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserSTORED_SYMBOL { + { + p.SetState(4260) + p.Stored_mode() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4263) + p.Generated_mode() + } + { + p.SetState(4264) + p.Identity_column_info() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentity_column_infoContext is an interface to support dynamic dispatch. +type IIdentity_column_infoContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IDENTITY_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + RR_BRACKET_SYMBOL() antlr.TerminalNode + Opt_start_with() IOpt_start_withContext + Opt_increment_by() IOpt_increment_byContext + Opt_maxvalue() IOpt_maxvalueContext + Opt_minvalue() IOpt_minvalueContext + Opt_cycle() IOpt_cycleContext + + // IsIdentity_column_infoContext differentiates from other interfaces. + IsIdentity_column_infoContext() +} + +type Identity_column_infoContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentity_column_infoContext() *Identity_column_infoContext { + var p = new(Identity_column_infoContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_identity_column_info + return p +} + +func InitEmptyIdentity_column_infoContext(p *Identity_column_infoContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_identity_column_info +} + +func (*Identity_column_infoContext) IsIdentity_column_infoContext() {} + +func NewIdentity_column_infoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Identity_column_infoContext { + var p = new(Identity_column_infoContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_identity_column_info + + return p +} + +func (s *Identity_column_infoContext) GetParser() antlr.Parser { return s.parser } + +func (s *Identity_column_infoContext) IDENTITY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIDENTITY_SYMBOL, 0) +} + +func (s *Identity_column_infoContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Identity_column_infoContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Identity_column_infoContext) Opt_start_with() IOpt_start_withContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_start_withContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_start_withContext) +} + +func (s *Identity_column_infoContext) Opt_increment_by() IOpt_increment_byContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_increment_byContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_increment_byContext) +} + +func (s *Identity_column_infoContext) Opt_maxvalue() IOpt_maxvalueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_maxvalueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_maxvalueContext) +} + +func (s *Identity_column_infoContext) Opt_minvalue() IOpt_minvalueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_minvalueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_minvalueContext) +} + +func (s *Identity_column_infoContext) Opt_cycle() IOpt_cycleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_cycleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_cycleContext) +} + +func (s *Identity_column_infoContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Identity_column_infoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Identity_column_infoContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterIdentity_column_info(s) + } +} + +func (s *Identity_column_infoContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitIdentity_column_info(s) + } +} + +func (s *Identity_column_infoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitIdentity_column_info(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Identity_column_info() (localctx IIdentity_column_infoContext) { + localctx = NewIdentity_column_infoContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 630, GoogleSQLParserRULE_identity_column_info) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4268) + p.Match(GoogleSQLParserIDENTITY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4269) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4271) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserSTART_SYMBOL { + { + p.SetState(4270) + p.Opt_start_with() + } + + } + p.SetState(4274) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserINCREMENT_SYMBOL { + { + p.SetState(4273) + p.Opt_increment_by() + } + + } + p.SetState(4277) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserMAXVALUE_SYMBOL { + { + p.SetState(4276) + p.Opt_maxvalue() + } + + } + p.SetState(4280) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserMINVALUE_SYMBOL { + { + p.SetState(4279) + p.Opt_minvalue() + } + + } + p.SetState(4283) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCYCLE_SYMBOL || _la == GoogleSQLParserNO_SYMBOL { + { + p.SetState(4282) + p.Opt_cycle() + } + + } + { + p.SetState(4285) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_start_withContext is an interface to support dynamic dispatch. +type IOpt_start_withContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + START_SYMBOL() antlr.TerminalNode + WITH_SYMBOL() antlr.TerminalNode + Signed_numeric_literal() ISigned_numeric_literalContext + + // IsOpt_start_withContext differentiates from other interfaces. + IsOpt_start_withContext() +} + +type Opt_start_withContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_start_withContext() *Opt_start_withContext { + var p = new(Opt_start_withContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_start_with + return p +} + +func InitEmptyOpt_start_withContext(p *Opt_start_withContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_start_with +} + +func (*Opt_start_withContext) IsOpt_start_withContext() {} + +func NewOpt_start_withContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_start_withContext { + var p = new(Opt_start_withContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_start_with + + return p +} + +func (s *Opt_start_withContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_start_withContext) START_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTART_SYMBOL, 0) +} + +func (s *Opt_start_withContext) WITH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWITH_SYMBOL, 0) +} + +func (s *Opt_start_withContext) Signed_numeric_literal() ISigned_numeric_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISigned_numeric_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISigned_numeric_literalContext) +} + +func (s *Opt_start_withContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_start_withContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_start_withContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_start_with(s) + } +} + +func (s *Opt_start_withContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_start_with(s) + } +} + +func (s *Opt_start_withContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_start_with(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_start_with() (localctx IOpt_start_withContext) { + localctx = NewOpt_start_withContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 632, GoogleSQLParserRULE_opt_start_with) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4287) + p.Match(GoogleSQLParserSTART_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4288) + p.Match(GoogleSQLParserWITH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4289) + p.Signed_numeric_literal() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_increment_byContext is an interface to support dynamic dispatch. +type IOpt_increment_byContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INCREMENT_SYMBOL() antlr.TerminalNode + BY_SYMBOL() antlr.TerminalNode + Signed_numeric_literal() ISigned_numeric_literalContext + + // IsOpt_increment_byContext differentiates from other interfaces. + IsOpt_increment_byContext() +} + +type Opt_increment_byContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_increment_byContext() *Opt_increment_byContext { + var p = new(Opt_increment_byContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_increment_by + return p +} + +func InitEmptyOpt_increment_byContext(p *Opt_increment_byContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_increment_by +} + +func (*Opt_increment_byContext) IsOpt_increment_byContext() {} + +func NewOpt_increment_byContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_increment_byContext { + var p = new(Opt_increment_byContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_increment_by + + return p +} + +func (s *Opt_increment_byContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_increment_byContext) INCREMENT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINCREMENT_SYMBOL, 0) +} + +func (s *Opt_increment_byContext) BY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBY_SYMBOL, 0) +} + +func (s *Opt_increment_byContext) Signed_numeric_literal() ISigned_numeric_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISigned_numeric_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISigned_numeric_literalContext) +} + +func (s *Opt_increment_byContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_increment_byContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_increment_byContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_increment_by(s) + } +} + +func (s *Opt_increment_byContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_increment_by(s) + } +} + +func (s *Opt_increment_byContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_increment_by(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_increment_by() (localctx IOpt_increment_byContext) { + localctx = NewOpt_increment_byContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 634, GoogleSQLParserRULE_opt_increment_by) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4291) + p.Match(GoogleSQLParserINCREMENT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4292) + p.Match(GoogleSQLParserBY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4293) + p.Signed_numeric_literal() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_maxvalueContext is an interface to support dynamic dispatch. +type IOpt_maxvalueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MAXVALUE_SYMBOL() antlr.TerminalNode + Signed_numeric_literal() ISigned_numeric_literalContext + + // IsOpt_maxvalueContext differentiates from other interfaces. + IsOpt_maxvalueContext() +} + +type Opt_maxvalueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_maxvalueContext() *Opt_maxvalueContext { + var p = new(Opt_maxvalueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_maxvalue + return p +} + +func InitEmptyOpt_maxvalueContext(p *Opt_maxvalueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_maxvalue +} + +func (*Opt_maxvalueContext) IsOpt_maxvalueContext() {} + +func NewOpt_maxvalueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_maxvalueContext { + var p = new(Opt_maxvalueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_maxvalue + + return p +} + +func (s *Opt_maxvalueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_maxvalueContext) MAXVALUE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMAXVALUE_SYMBOL, 0) +} + +func (s *Opt_maxvalueContext) Signed_numeric_literal() ISigned_numeric_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISigned_numeric_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISigned_numeric_literalContext) +} + +func (s *Opt_maxvalueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_maxvalueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_maxvalueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_maxvalue(s) + } +} + +func (s *Opt_maxvalueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_maxvalue(s) + } +} + +func (s *Opt_maxvalueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_maxvalue(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_maxvalue() (localctx IOpt_maxvalueContext) { + localctx = NewOpt_maxvalueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 636, GoogleSQLParserRULE_opt_maxvalue) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4295) + p.Match(GoogleSQLParserMAXVALUE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4296) + p.Signed_numeric_literal() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_minvalueContext is an interface to support dynamic dispatch. +type IOpt_minvalueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MINVALUE_SYMBOL() antlr.TerminalNode + Signed_numeric_literal() ISigned_numeric_literalContext + + // IsOpt_minvalueContext differentiates from other interfaces. + IsOpt_minvalueContext() +} + +type Opt_minvalueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_minvalueContext() *Opt_minvalueContext { + var p = new(Opt_minvalueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_minvalue + return p +} + +func InitEmptyOpt_minvalueContext(p *Opt_minvalueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_minvalue +} + +func (*Opt_minvalueContext) IsOpt_minvalueContext() {} + +func NewOpt_minvalueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_minvalueContext { + var p = new(Opt_minvalueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_minvalue + + return p +} + +func (s *Opt_minvalueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_minvalueContext) MINVALUE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMINVALUE_SYMBOL, 0) +} + +func (s *Opt_minvalueContext) Signed_numeric_literal() ISigned_numeric_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISigned_numeric_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISigned_numeric_literalContext) +} + +func (s *Opt_minvalueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_minvalueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_minvalueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_minvalue(s) + } +} + +func (s *Opt_minvalueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_minvalue(s) + } +} + +func (s *Opt_minvalueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_minvalue(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_minvalue() (localctx IOpt_minvalueContext) { + localctx = NewOpt_minvalueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 638, GoogleSQLParserRULE_opt_minvalue) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4298) + p.Match(GoogleSQLParserMINVALUE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4299) + p.Signed_numeric_literal() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_cycleContext is an interface to support dynamic dispatch. +type IOpt_cycleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CYCLE_SYMBOL() antlr.TerminalNode + NO_SYMBOL() antlr.TerminalNode + + // IsOpt_cycleContext differentiates from other interfaces. + IsOpt_cycleContext() +} + +type Opt_cycleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_cycleContext() *Opt_cycleContext { + var p = new(Opt_cycleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_cycle + return p +} + +func InitEmptyOpt_cycleContext(p *Opt_cycleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_cycle +} + +func (*Opt_cycleContext) IsOpt_cycleContext() {} + +func NewOpt_cycleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_cycleContext { + var p = new(Opt_cycleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_cycle + + return p +} + +func (s *Opt_cycleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_cycleContext) CYCLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCYCLE_SYMBOL, 0) +} + +func (s *Opt_cycleContext) NO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNO_SYMBOL, 0) +} + +func (s *Opt_cycleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_cycleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_cycleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_cycle(s) + } +} + +func (s *Opt_cycleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_cycle(s) + } +} + +func (s *Opt_cycleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_cycle(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_cycle() (localctx IOpt_cycleContext) { + localctx = NewOpt_cycleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 640, GoogleSQLParserRULE_opt_cycle) + p.SetState(4304) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserCYCLE_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4301) + p.Match(GoogleSQLParserCYCLE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserNO_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4302) + p.Match(GoogleSQLParserNO_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4303) + p.Match(GoogleSQLParserCYCLE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISigned_numeric_literalContext is an interface to support dynamic dispatch. +type ISigned_numeric_literalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Integer_literal() IInteger_literalContext + Numeric_literal() INumeric_literalContext + Bignumeric_literal() IBignumeric_literalContext + Floating_point_literal() IFloating_point_literalContext + MINUS_OPERATOR() antlr.TerminalNode + + // IsSigned_numeric_literalContext differentiates from other interfaces. + IsSigned_numeric_literalContext() +} + +type Signed_numeric_literalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySigned_numeric_literalContext() *Signed_numeric_literalContext { + var p = new(Signed_numeric_literalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_signed_numeric_literal + return p +} + +func InitEmptySigned_numeric_literalContext(p *Signed_numeric_literalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_signed_numeric_literal +} + +func (*Signed_numeric_literalContext) IsSigned_numeric_literalContext() {} + +func NewSigned_numeric_literalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Signed_numeric_literalContext { + var p = new(Signed_numeric_literalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_signed_numeric_literal + + return p +} + +func (s *Signed_numeric_literalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Signed_numeric_literalContext) Integer_literal() IInteger_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInteger_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInteger_literalContext) +} + +func (s *Signed_numeric_literalContext) Numeric_literal() INumeric_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumeric_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumeric_literalContext) +} + +func (s *Signed_numeric_literalContext) Bignumeric_literal() IBignumeric_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBignumeric_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBignumeric_literalContext) +} + +func (s *Signed_numeric_literalContext) Floating_point_literal() IFloating_point_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFloating_point_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFloating_point_literalContext) +} + +func (s *Signed_numeric_literalContext) MINUS_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMINUS_OPERATOR, 0) +} + +func (s *Signed_numeric_literalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Signed_numeric_literalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Signed_numeric_literalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSigned_numeric_literal(s) + } +} + +func (s *Signed_numeric_literalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSigned_numeric_literal(s) + } +} + +func (s *Signed_numeric_literalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSigned_numeric_literal(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Signed_numeric_literal() (localctx ISigned_numeric_literalContext) { + localctx = NewSigned_numeric_literalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 642, GoogleSQLParserRULE_signed_numeric_literal) + p.SetState(4314) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 507, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4306) + p.Integer_literal() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4307) + p.Numeric_literal() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4308) + p.Bignumeric_literal() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4309) + p.Floating_point_literal() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(4310) + p.Match(GoogleSQLParserMINUS_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4311) + p.Integer_literal() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(4312) + p.Match(GoogleSQLParserMINUS_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4313) + p.Floating_point_literal() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStored_modeContext is an interface to support dynamic dispatch. +type IStored_modeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STORED_SYMBOL() antlr.TerminalNode + VOLATILE_SYMBOL() antlr.TerminalNode + + // IsStored_modeContext differentiates from other interfaces. + IsStored_modeContext() +} + +type Stored_modeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStored_modeContext() *Stored_modeContext { + var p = new(Stored_modeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_stored_mode + return p +} + +func InitEmptyStored_modeContext(p *Stored_modeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_stored_mode +} + +func (*Stored_modeContext) IsStored_modeContext() {} + +func NewStored_modeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stored_modeContext { + var p = new(Stored_modeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_stored_mode + + return p +} + +func (s *Stored_modeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stored_modeContext) STORED_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTORED_SYMBOL, 0) +} + +func (s *Stored_modeContext) VOLATILE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserVOLATILE_SYMBOL, 0) +} + +func (s *Stored_modeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stored_modeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stored_modeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterStored_mode(s) + } +} + +func (s *Stored_modeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitStored_mode(s) + } +} + +func (s *Stored_modeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitStored_mode(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Stored_mode() (localctx IStored_modeContext) { + localctx = NewStored_modeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 644, GoogleSQLParserRULE_stored_mode) + p.SetState(4319) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 508, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4316) + p.Match(GoogleSQLParserSTORED_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4317) + p.Match(GoogleSQLParserVOLATILE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4318) + p.Match(GoogleSQLParserSTORED_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGenerated_modeContext is an interface to support dynamic dispatch. +type IGenerated_modeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GENERATED_SYMBOL() antlr.TerminalNode + AS_SYMBOL() antlr.TerminalNode + ALWAYS_SYMBOL() antlr.TerminalNode + BY_SYMBOL() antlr.TerminalNode + DEFAULT_SYMBOL() antlr.TerminalNode + + // IsGenerated_modeContext differentiates from other interfaces. + IsGenerated_modeContext() +} + +type Generated_modeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGenerated_modeContext() *Generated_modeContext { + var p = new(Generated_modeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_generated_mode + return p +} + +func InitEmptyGenerated_modeContext(p *Generated_modeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_generated_mode +} + +func (*Generated_modeContext) IsGenerated_modeContext() {} + +func NewGenerated_modeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generated_modeContext { + var p = new(Generated_modeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_generated_mode + + return p +} + +func (s *Generated_modeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Generated_modeContext) GENERATED_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserGENERATED_SYMBOL, 0) +} + +func (s *Generated_modeContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Generated_modeContext) ALWAYS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserALWAYS_SYMBOL, 0) +} + +func (s *Generated_modeContext) BY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBY_SYMBOL, 0) +} + +func (s *Generated_modeContext) DEFAULT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDEFAULT_SYMBOL, 0) +} + +func (s *Generated_modeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Generated_modeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Generated_modeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGenerated_mode(s) + } +} + +func (s *Generated_modeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGenerated_mode(s) + } +} + +func (s *Generated_modeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGenerated_mode(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Generated_mode() (localctx IGenerated_modeContext) { + localctx = NewGenerated_modeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 646, GoogleSQLParserRULE_generated_mode) + p.SetState(4331) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 509, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4321) + p.Match(GoogleSQLParserGENERATED_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4322) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4323) + p.Match(GoogleSQLParserGENERATED_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4324) + p.Match(GoogleSQLParserALWAYS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4325) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4326) + p.Match(GoogleSQLParserGENERATED_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4327) + p.Match(GoogleSQLParserBY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4328) + p.Match(GoogleSQLParserDEFAULT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4329) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4330) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_schema_innerContext is an interface to support dynamic dispatch. +type IColumn_schema_innerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Raw_column_schema_inner() IRaw_column_schema_innerContext + Opt_type_parameters() IOpt_type_parametersContext + + // IsColumn_schema_innerContext differentiates from other interfaces. + IsColumn_schema_innerContext() +} + +type Column_schema_innerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_schema_innerContext() *Column_schema_innerContext { + var p = new(Column_schema_innerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_column_schema_inner + return p +} + +func InitEmptyColumn_schema_innerContext(p *Column_schema_innerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_column_schema_inner +} + +func (*Column_schema_innerContext) IsColumn_schema_innerContext() {} + +func NewColumn_schema_innerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_schema_innerContext { + var p = new(Column_schema_innerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_column_schema_inner + + return p +} + +func (s *Column_schema_innerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_schema_innerContext) Raw_column_schema_inner() IRaw_column_schema_innerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRaw_column_schema_innerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRaw_column_schema_innerContext) +} + +func (s *Column_schema_innerContext) Opt_type_parameters() IOpt_type_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_type_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_type_parametersContext) +} + +func (s *Column_schema_innerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_schema_innerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_schema_innerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterColumn_schema_inner(s) + } +} + +func (s *Column_schema_innerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitColumn_schema_inner(s) + } +} + +func (s *Column_schema_innerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitColumn_schema_inner(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Column_schema_inner() (localctx IColumn_schema_innerContext) { + localctx = NewColumn_schema_innerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 648, GoogleSQLParserRULE_column_schema_inner) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4333) + p.Raw_column_schema_inner() + } + p.SetState(4335) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL { + { + p.SetState(4334) + p.Opt_type_parameters() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRaw_column_schema_innerContext is an interface to support dynamic dispatch. +type IRaw_column_schema_innerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Simple_column_schema_inner() ISimple_column_schema_innerContext + Array_column_schema_inner() IArray_column_schema_innerContext + Struct_column_schema_inner() IStruct_column_schema_innerContext + Range_column_schema_inner() IRange_column_schema_innerContext + + // IsRaw_column_schema_innerContext differentiates from other interfaces. + IsRaw_column_schema_innerContext() +} + +type Raw_column_schema_innerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRaw_column_schema_innerContext() *Raw_column_schema_innerContext { + var p = new(Raw_column_schema_innerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_raw_column_schema_inner + return p +} + +func InitEmptyRaw_column_schema_innerContext(p *Raw_column_schema_innerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_raw_column_schema_inner +} + +func (*Raw_column_schema_innerContext) IsRaw_column_schema_innerContext() {} + +func NewRaw_column_schema_innerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Raw_column_schema_innerContext { + var p = new(Raw_column_schema_innerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_raw_column_schema_inner + + return p +} + +func (s *Raw_column_schema_innerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Raw_column_schema_innerContext) Simple_column_schema_inner() ISimple_column_schema_innerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimple_column_schema_innerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimple_column_schema_innerContext) +} + +func (s *Raw_column_schema_innerContext) Array_column_schema_inner() IArray_column_schema_innerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArray_column_schema_innerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IArray_column_schema_innerContext) +} + +func (s *Raw_column_schema_innerContext) Struct_column_schema_inner() IStruct_column_schema_innerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStruct_column_schema_innerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStruct_column_schema_innerContext) +} + +func (s *Raw_column_schema_innerContext) Range_column_schema_inner() IRange_column_schema_innerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_column_schema_innerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRange_column_schema_innerContext) +} + +func (s *Raw_column_schema_innerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Raw_column_schema_innerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Raw_column_schema_innerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterRaw_column_schema_inner(s) + } +} + +func (s *Raw_column_schema_innerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitRaw_column_schema_inner(s) + } +} + +func (s *Raw_column_schema_innerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitRaw_column_schema_inner(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Raw_column_schema_inner() (localctx IRaw_column_schema_innerContext) { + localctx = NewRaw_column_schema_innerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 650, GoogleSQLParserRULE_raw_column_schema_inner) + p.SetState(4341) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserINTERVAL_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4337) + p.Simple_column_schema_inner() + } + + case GoogleSQLParserARRAY_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4338) + p.Array_column_schema_inner() + } + + case GoogleSQLParserSTRUCT_SYMBOL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4339) + p.Struct_column_schema_inner() + } + + case GoogleSQLParserRANGE_SYMBOL: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4340) + p.Range_column_schema_inner() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRange_column_schema_innerContext is an interface to support dynamic dispatch. +type IRange_column_schema_innerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RANGE_SYMBOL() antlr.TerminalNode + Template_type_open() ITemplate_type_openContext + Field_schema() IField_schemaContext + Template_type_close() ITemplate_type_closeContext + + // IsRange_column_schema_innerContext differentiates from other interfaces. + IsRange_column_schema_innerContext() +} + +type Range_column_schema_innerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRange_column_schema_innerContext() *Range_column_schema_innerContext { + var p = new(Range_column_schema_innerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_range_column_schema_inner + return p +} + +func InitEmptyRange_column_schema_innerContext(p *Range_column_schema_innerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_range_column_schema_inner +} + +func (*Range_column_schema_innerContext) IsRange_column_schema_innerContext() {} + +func NewRange_column_schema_innerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Range_column_schema_innerContext { + var p = new(Range_column_schema_innerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_range_column_schema_inner + + return p +} + +func (s *Range_column_schema_innerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Range_column_schema_innerContext) RANGE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRANGE_SYMBOL, 0) +} + +func (s *Range_column_schema_innerContext) Template_type_open() ITemplate_type_openContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemplate_type_openContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemplate_type_openContext) +} + +func (s *Range_column_schema_innerContext) Field_schema() IField_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IField_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IField_schemaContext) +} + +func (s *Range_column_schema_innerContext) Template_type_close() ITemplate_type_closeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemplate_type_closeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemplate_type_closeContext) +} + +func (s *Range_column_schema_innerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Range_column_schema_innerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Range_column_schema_innerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterRange_column_schema_inner(s) + } +} + +func (s *Range_column_schema_innerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitRange_column_schema_inner(s) + } +} + +func (s *Range_column_schema_innerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitRange_column_schema_inner(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Range_column_schema_inner() (localctx IRange_column_schema_innerContext) { + localctx = NewRange_column_schema_innerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 652, GoogleSQLParserRULE_range_column_schema_inner) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4343) + p.Match(GoogleSQLParserRANGE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4344) + p.Template_type_open() + } + { + p.SetState(4345) + p.Field_schema() + } + { + p.SetState(4346) + p.Template_type_close() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStruct_column_schema_innerContext is an interface to support dynamic dispatch. +type IStruct_column_schema_innerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STRUCT_SYMBOL() antlr.TerminalNode + Template_type_open() ITemplate_type_openContext + Template_type_close() ITemplate_type_closeContext + AllStruct_column_field() []IStruct_column_fieldContext + Struct_column_field(i int) IStruct_column_fieldContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsStruct_column_schema_innerContext differentiates from other interfaces. + IsStruct_column_schema_innerContext() +} + +type Struct_column_schema_innerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStruct_column_schema_innerContext() *Struct_column_schema_innerContext { + var p = new(Struct_column_schema_innerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_struct_column_schema_inner + return p +} + +func InitEmptyStruct_column_schema_innerContext(p *Struct_column_schema_innerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_struct_column_schema_inner +} + +func (*Struct_column_schema_innerContext) IsStruct_column_schema_innerContext() {} + +func NewStruct_column_schema_innerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Struct_column_schema_innerContext { + var p = new(Struct_column_schema_innerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_struct_column_schema_inner + + return p +} + +func (s *Struct_column_schema_innerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Struct_column_schema_innerContext) STRUCT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTRUCT_SYMBOL, 0) +} + +func (s *Struct_column_schema_innerContext) Template_type_open() ITemplate_type_openContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemplate_type_openContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemplate_type_openContext) +} + +func (s *Struct_column_schema_innerContext) Template_type_close() ITemplate_type_closeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemplate_type_closeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemplate_type_closeContext) +} + +func (s *Struct_column_schema_innerContext) AllStruct_column_field() []IStruct_column_fieldContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStruct_column_fieldContext); ok { + len++ + } + } + + tst := make([]IStruct_column_fieldContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStruct_column_fieldContext); ok { + tst[i] = t.(IStruct_column_fieldContext) + i++ + } + } + + return tst +} + +func (s *Struct_column_schema_innerContext) Struct_column_field(i int) IStruct_column_fieldContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStruct_column_fieldContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStruct_column_fieldContext) +} + +func (s *Struct_column_schema_innerContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Struct_column_schema_innerContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Struct_column_schema_innerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Struct_column_schema_innerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Struct_column_schema_innerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterStruct_column_schema_inner(s) + } +} + +func (s *Struct_column_schema_innerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitStruct_column_schema_inner(s) + } +} + +func (s *Struct_column_schema_innerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitStruct_column_schema_inner(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Struct_column_schema_inner() (localctx IStruct_column_schema_innerContext) { + localctx = NewStruct_column_schema_innerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 654, GoogleSQLParserRULE_struct_column_schema_inner) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4348) + p.Match(GoogleSQLParserSTRUCT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4349) + p.Template_type_open() + } + p.SetState(4358) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-56)) & ^0x3f) == 0 && ((int64(1)<<(_la-56))&-254304519003570175) != 0) || ((int64((_la-120)) & ^0x3f) == 0 && ((int64(1)<<(_la-120))&-1) != 0) || ((int64((_la-184)) & ^0x3f) == 0 && ((int64(1)<<(_la-184))&-1) != 0) || ((int64((_la-248)) & ^0x3f) == 0 && ((int64(1)<<(_la-248))&140737488354815) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&33488865) != 0) { + { + p.SetState(4350) + p.Struct_column_field() + } + p.SetState(4355) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(4351) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4352) + p.Struct_column_field() + } + + p.SetState(4357) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(4360) + p.Template_type_close() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStruct_column_fieldContext is an interface to support dynamic dispatch. +type IStruct_column_fieldContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_schema_inner() IColumn_schema_innerContext + Collate_clause() ICollate_clauseContext + Opt_field_attributes() IOpt_field_attributesContext + Identifier() IIdentifierContext + Field_schema() IField_schemaContext + + // IsStruct_column_fieldContext differentiates from other interfaces. + IsStruct_column_fieldContext() +} + +type Struct_column_fieldContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStruct_column_fieldContext() *Struct_column_fieldContext { + var p = new(Struct_column_fieldContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_struct_column_field + return p +} + +func InitEmptyStruct_column_fieldContext(p *Struct_column_fieldContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_struct_column_field +} + +func (*Struct_column_fieldContext) IsStruct_column_fieldContext() {} + +func NewStruct_column_fieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Struct_column_fieldContext { + var p = new(Struct_column_fieldContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_struct_column_field + + return p +} + +func (s *Struct_column_fieldContext) GetParser() antlr.Parser { return s.parser } + +func (s *Struct_column_fieldContext) Column_schema_inner() IColumn_schema_innerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_schema_innerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_schema_innerContext) +} + +func (s *Struct_column_fieldContext) Collate_clause() ICollate_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollate_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollate_clauseContext) +} + +func (s *Struct_column_fieldContext) Opt_field_attributes() IOpt_field_attributesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_field_attributesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_field_attributesContext) +} + +func (s *Struct_column_fieldContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Struct_column_fieldContext) Field_schema() IField_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IField_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IField_schemaContext) +} + +func (s *Struct_column_fieldContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Struct_column_fieldContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Struct_column_fieldContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterStruct_column_field(s) + } +} + +func (s *Struct_column_fieldContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitStruct_column_field(s) + } +} + +func (s *Struct_column_fieldContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitStruct_column_field(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Struct_column_field() (localctx IStruct_column_fieldContext) { + localctx = NewStruct_column_fieldContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 656, GoogleSQLParserRULE_struct_column_field) + var _la int + + p.SetState(4372) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 516, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4362) + p.Column_schema_inner() + } + p.SetState(4364) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCOLLATE_SYMBOL { + { + p.SetState(4363) + p.Collate_clause() + } + + } + p.SetState(4367) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserNOT_SYMBOL { + { + p.SetState(4366) + p.Opt_field_attributes() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4369) + p.Identifier() + } + { + p.SetState(4370) + p.Field_schema() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISimple_column_schema_innerContext is an interface to support dynamic dispatch. +type ISimple_column_schema_innerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Path_expression() IPath_expressionContext + INTERVAL_SYMBOL() antlr.TerminalNode + + // IsSimple_column_schema_innerContext differentiates from other interfaces. + IsSimple_column_schema_innerContext() +} + +type Simple_column_schema_innerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySimple_column_schema_innerContext() *Simple_column_schema_innerContext { + var p = new(Simple_column_schema_innerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_simple_column_schema_inner + return p +} + +func InitEmptySimple_column_schema_innerContext(p *Simple_column_schema_innerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_simple_column_schema_inner +} + +func (*Simple_column_schema_innerContext) IsSimple_column_schema_innerContext() {} + +func NewSimple_column_schema_innerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_column_schema_innerContext { + var p = new(Simple_column_schema_innerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_simple_column_schema_inner + + return p +} + +func (s *Simple_column_schema_innerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Simple_column_schema_innerContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Simple_column_schema_innerContext) INTERVAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINTERVAL_SYMBOL, 0) +} + +func (s *Simple_column_schema_innerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Simple_column_schema_innerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Simple_column_schema_innerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSimple_column_schema_inner(s) + } +} + +func (s *Simple_column_schema_innerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSimple_column_schema_inner(s) + } +} + +func (s *Simple_column_schema_innerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSimple_column_schema_inner(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Simple_column_schema_inner() (localctx ISimple_column_schema_innerContext) { + localctx = NewSimple_column_schema_innerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 658, GoogleSQLParserRULE_simple_column_schema_inner) + p.SetState(4376) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4374) + p.Path_expression() + } + + case GoogleSQLParserINTERVAL_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4375) + p.Match(GoogleSQLParserINTERVAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IArray_column_schema_innerContext is an interface to support dynamic dispatch. +type IArray_column_schema_innerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ARRAY_SYMBOL() antlr.TerminalNode + Template_type_open() ITemplate_type_openContext + Field_schema() IField_schemaContext + Template_type_close() ITemplate_type_closeContext + + // IsArray_column_schema_innerContext differentiates from other interfaces. + IsArray_column_schema_innerContext() +} + +type Array_column_schema_innerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyArray_column_schema_innerContext() *Array_column_schema_innerContext { + var p = new(Array_column_schema_innerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_array_column_schema_inner + return p +} + +func InitEmptyArray_column_schema_innerContext(p *Array_column_schema_innerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_array_column_schema_inner +} + +func (*Array_column_schema_innerContext) IsArray_column_schema_innerContext() {} + +func NewArray_column_schema_innerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Array_column_schema_innerContext { + var p = new(Array_column_schema_innerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_array_column_schema_inner + + return p +} + +func (s *Array_column_schema_innerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Array_column_schema_innerContext) ARRAY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserARRAY_SYMBOL, 0) +} + +func (s *Array_column_schema_innerContext) Template_type_open() ITemplate_type_openContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemplate_type_openContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemplate_type_openContext) +} + +func (s *Array_column_schema_innerContext) Field_schema() IField_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IField_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IField_schemaContext) +} + +func (s *Array_column_schema_innerContext) Template_type_close() ITemplate_type_closeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemplate_type_closeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemplate_type_closeContext) +} + +func (s *Array_column_schema_innerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Array_column_schema_innerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Array_column_schema_innerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterArray_column_schema_inner(s) + } +} + +func (s *Array_column_schema_innerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitArray_column_schema_inner(s) + } +} + +func (s *Array_column_schema_innerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitArray_column_schema_inner(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Array_column_schema_inner() (localctx IArray_column_schema_innerContext) { + localctx = NewArray_column_schema_innerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 660, GoogleSQLParserRULE_array_column_schema_inner) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4378) + p.Match(GoogleSQLParserARRAY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4379) + p.Template_type_open() + } + { + p.SetState(4380) + p.Field_schema() + } + { + p.SetState(4381) + p.Template_type_close() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IField_schemaContext is an interface to support dynamic dispatch. +type IField_schemaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_schema_inner() IColumn_schema_innerContext + Collate_clause() ICollate_clauseContext + Opt_field_attributes() IOpt_field_attributesContext + Opt_options_list() IOpt_options_listContext + + // IsField_schemaContext differentiates from other interfaces. + IsField_schemaContext() +} + +type Field_schemaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyField_schemaContext() *Field_schemaContext { + var p = new(Field_schemaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_field_schema + return p +} + +func InitEmptyField_schemaContext(p *Field_schemaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_field_schema +} + +func (*Field_schemaContext) IsField_schemaContext() {} + +func NewField_schemaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Field_schemaContext { + var p = new(Field_schemaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_field_schema + + return p +} + +func (s *Field_schemaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Field_schemaContext) Column_schema_inner() IColumn_schema_innerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_schema_innerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_schema_innerContext) +} + +func (s *Field_schemaContext) Collate_clause() ICollate_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollate_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollate_clauseContext) +} + +func (s *Field_schemaContext) Opt_field_attributes() IOpt_field_attributesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_field_attributesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_field_attributesContext) +} + +func (s *Field_schemaContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Field_schemaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Field_schemaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Field_schemaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterField_schema(s) + } +} + +func (s *Field_schemaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitField_schema(s) + } +} + +func (s *Field_schemaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitField_schema(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Field_schema() (localctx IField_schemaContext) { + localctx = NewField_schemaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 662, GoogleSQLParserRULE_field_schema) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4383) + p.Column_schema_inner() + } + p.SetState(4385) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCOLLATE_SYMBOL { + { + p.SetState(4384) + p.Collate_clause() + } + + } + p.SetState(4388) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserNOT_SYMBOL { + { + p.SetState(4387) + p.Opt_field_attributes() + } + + } + p.SetState(4391) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(4390) + p.Opt_options_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_field_attributesContext is an interface to support dynamic dispatch. +type IOpt_field_attributesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Not_null_column_attribute() INot_null_column_attributeContext + + // IsOpt_field_attributesContext differentiates from other interfaces. + IsOpt_field_attributesContext() +} + +type Opt_field_attributesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_field_attributesContext() *Opt_field_attributesContext { + var p = new(Opt_field_attributesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_field_attributes + return p +} + +func InitEmptyOpt_field_attributesContext(p *Opt_field_attributesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_field_attributes +} + +func (*Opt_field_attributesContext) IsOpt_field_attributesContext() {} + +func NewOpt_field_attributesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_field_attributesContext { + var p = new(Opt_field_attributesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_field_attributes + + return p +} + +func (s *Opt_field_attributesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_field_attributesContext) Not_null_column_attribute() INot_null_column_attributeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INot_null_column_attributeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INot_null_column_attributeContext) +} + +func (s *Opt_field_attributesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_field_attributesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_field_attributesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_field_attributes(s) + } +} + +func (s *Opt_field_attributesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_field_attributes(s) + } +} + +func (s *Opt_field_attributesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_field_attributes(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_field_attributes() (localctx IOpt_field_attributesContext) { + localctx = NewOpt_field_attributesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 664, GoogleSQLParserRULE_opt_field_attributes) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4393) + p.Not_null_column_attribute() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INot_null_column_attributeContext is an interface to support dynamic dispatch. +type INot_null_column_attributeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOT_SYMBOL() antlr.TerminalNode + NULL_SYMBOL() antlr.TerminalNode + + // IsNot_null_column_attributeContext differentiates from other interfaces. + IsNot_null_column_attributeContext() +} + +type Not_null_column_attributeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNot_null_column_attributeContext() *Not_null_column_attributeContext { + var p = new(Not_null_column_attributeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_not_null_column_attribute + return p +} + +func InitEmptyNot_null_column_attributeContext(p *Not_null_column_attributeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_not_null_column_attribute +} + +func (*Not_null_column_attributeContext) IsNot_null_column_attributeContext() {} + +func NewNot_null_column_attributeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Not_null_column_attributeContext { + var p = new(Not_null_column_attributeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_not_null_column_attribute + + return p +} + +func (s *Not_null_column_attributeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Not_null_column_attributeContext) NOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNOT_SYMBOL, 0) +} + +func (s *Not_null_column_attributeContext) NULL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNULL_SYMBOL, 0) +} + +func (s *Not_null_column_attributeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Not_null_column_attributeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Not_null_column_attributeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterNot_null_column_attribute(s) + } +} + +func (s *Not_null_column_attributeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitNot_null_column_attribute(s) + } +} + +func (s *Not_null_column_attributeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitNot_null_column_attribute(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Not_null_column_attribute() (localctx INot_null_column_attributeContext) { + localctx = NewNot_null_column_attributeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 666, GoogleSQLParserRULE_not_null_column_attribute) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4395) + p.Match(GoogleSQLParserNOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4396) + p.Match(GoogleSQLParserNULL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrimary_key_or_table_constraint_specContext is an interface to support dynamic dispatch. +type IPrimary_key_or_table_constraint_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Primary_key_spec() IPrimary_key_specContext + Table_constraint_spec() ITable_constraint_specContext + + // IsPrimary_key_or_table_constraint_specContext differentiates from other interfaces. + IsPrimary_key_or_table_constraint_specContext() +} + +type Primary_key_or_table_constraint_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrimary_key_or_table_constraint_specContext() *Primary_key_or_table_constraint_specContext { + var p = new(Primary_key_or_table_constraint_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_primary_key_or_table_constraint_spec + return p +} + +func InitEmptyPrimary_key_or_table_constraint_specContext(p *Primary_key_or_table_constraint_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_primary_key_or_table_constraint_spec +} + +func (*Primary_key_or_table_constraint_specContext) IsPrimary_key_or_table_constraint_specContext() {} + +func NewPrimary_key_or_table_constraint_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Primary_key_or_table_constraint_specContext { + var p = new(Primary_key_or_table_constraint_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_primary_key_or_table_constraint_spec + + return p +} + +func (s *Primary_key_or_table_constraint_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Primary_key_or_table_constraint_specContext) Primary_key_spec() IPrimary_key_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimary_key_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimary_key_specContext) +} + +func (s *Primary_key_or_table_constraint_specContext) Table_constraint_spec() ITable_constraint_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_constraint_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_constraint_specContext) +} + +func (s *Primary_key_or_table_constraint_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Primary_key_or_table_constraint_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Primary_key_or_table_constraint_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPrimary_key_or_table_constraint_spec(s) + } +} + +func (s *Primary_key_or_table_constraint_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPrimary_key_or_table_constraint_spec(s) + } +} + +func (s *Primary_key_or_table_constraint_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPrimary_key_or_table_constraint_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Primary_key_or_table_constraint_spec() (localctx IPrimary_key_or_table_constraint_specContext) { + localctx = NewPrimary_key_or_table_constraint_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 668, GoogleSQLParserRULE_primary_key_or_table_constraint_spec) + p.SetState(4400) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserPRIMARY_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4398) + p.Primary_key_spec() + } + + case GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4399) + p.Table_constraint_spec() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_if_not_existsContext is an interface to support dynamic dispatch. +type IOpt_if_not_existsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IF_SYMBOL() antlr.TerminalNode + NOT_SYMBOL() antlr.TerminalNode + EXISTS_SYMBOL() antlr.TerminalNode + + // IsOpt_if_not_existsContext differentiates from other interfaces. + IsOpt_if_not_existsContext() +} + +type Opt_if_not_existsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_if_not_existsContext() *Opt_if_not_existsContext { + var p = new(Opt_if_not_existsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_if_not_exists + return p +} + +func InitEmptyOpt_if_not_existsContext(p *Opt_if_not_existsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_if_not_exists +} + +func (*Opt_if_not_existsContext) IsOpt_if_not_existsContext() {} + +func NewOpt_if_not_existsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_if_not_existsContext { + var p = new(Opt_if_not_existsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_if_not_exists + + return p +} + +func (s *Opt_if_not_existsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_if_not_existsContext) IF_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIF_SYMBOL, 0) +} + +func (s *Opt_if_not_existsContext) NOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNOT_SYMBOL, 0) +} + +func (s *Opt_if_not_existsContext) EXISTS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXISTS_SYMBOL, 0) +} + +func (s *Opt_if_not_existsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_if_not_existsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_if_not_existsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_if_not_exists(s) + } +} + +func (s *Opt_if_not_existsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_if_not_exists(s) + } +} + +func (s *Opt_if_not_existsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_if_not_exists(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_if_not_exists() (localctx IOpt_if_not_existsContext) { + localctx = NewOpt_if_not_existsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 670, GoogleSQLParserRULE_opt_if_not_exists) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4402) + p.Match(GoogleSQLParserIF_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4403) + p.Match(GoogleSQLParserNOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4404) + p.Match(GoogleSQLParserEXISTS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrimary_key_specContext is an interface to support dynamic dispatch. +type IPrimary_key_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PRIMARY_SYMBOL() antlr.TerminalNode + KEY_SYMBOL() antlr.TerminalNode + Primary_key_element_list() IPrimary_key_element_listContext + Constraint_enforcement() IConstraint_enforcementContext + Opt_options_list() IOpt_options_listContext + + // IsPrimary_key_specContext differentiates from other interfaces. + IsPrimary_key_specContext() +} + +type Primary_key_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrimary_key_specContext() *Primary_key_specContext { + var p = new(Primary_key_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_primary_key_spec + return p +} + +func InitEmptyPrimary_key_specContext(p *Primary_key_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_primary_key_spec +} + +func (*Primary_key_specContext) IsPrimary_key_specContext() {} + +func NewPrimary_key_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Primary_key_specContext { + var p = new(Primary_key_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_primary_key_spec + + return p +} + +func (s *Primary_key_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Primary_key_specContext) PRIMARY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPRIMARY_SYMBOL, 0) +} + +func (s *Primary_key_specContext) KEY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserKEY_SYMBOL, 0) +} + +func (s *Primary_key_specContext) Primary_key_element_list() IPrimary_key_element_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimary_key_element_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimary_key_element_listContext) +} + +func (s *Primary_key_specContext) Constraint_enforcement() IConstraint_enforcementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_enforcementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_enforcementContext) +} + +func (s *Primary_key_specContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Primary_key_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Primary_key_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Primary_key_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPrimary_key_spec(s) + } +} + +func (s *Primary_key_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPrimary_key_spec(s) + } +} + +func (s *Primary_key_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPrimary_key_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Primary_key_spec() (localctx IPrimary_key_specContext) { + localctx = NewPrimary_key_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 672, GoogleSQLParserRULE_primary_key_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4406) + p.Match(GoogleSQLParserPRIMARY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4407) + p.Match(GoogleSQLParserKEY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4408) + p.Primary_key_element_list() + } + p.SetState(4410) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserNOT_SYMBOL || _la == GoogleSQLParserENFORCED_SYMBOL { + { + p.SetState(4409) + p.Constraint_enforcement() + } + + } + p.SetState(4413) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(4412) + p.Opt_options_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrimary_key_element_listContext is an interface to support dynamic dispatch. +type IPrimary_key_element_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + RR_BRACKET_SYMBOL() antlr.TerminalNode + AllPrimary_key_element() []IPrimary_key_elementContext + Primary_key_element(i int) IPrimary_key_elementContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsPrimary_key_element_listContext differentiates from other interfaces. + IsPrimary_key_element_listContext() +} + +type Primary_key_element_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrimary_key_element_listContext() *Primary_key_element_listContext { + var p = new(Primary_key_element_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_primary_key_element_list + return p +} + +func InitEmptyPrimary_key_element_listContext(p *Primary_key_element_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_primary_key_element_list +} + +func (*Primary_key_element_listContext) IsPrimary_key_element_listContext() {} + +func NewPrimary_key_element_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Primary_key_element_listContext { + var p = new(Primary_key_element_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_primary_key_element_list + + return p +} + +func (s *Primary_key_element_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Primary_key_element_listContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Primary_key_element_listContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Primary_key_element_listContext) AllPrimary_key_element() []IPrimary_key_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPrimary_key_elementContext); ok { + len++ + } + } + + tst := make([]IPrimary_key_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPrimary_key_elementContext); ok { + tst[i] = t.(IPrimary_key_elementContext) + i++ + } + } + + return tst +} + +func (s *Primary_key_element_listContext) Primary_key_element(i int) IPrimary_key_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimary_key_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPrimary_key_elementContext) +} + +func (s *Primary_key_element_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Primary_key_element_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Primary_key_element_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Primary_key_element_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Primary_key_element_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPrimary_key_element_list(s) + } +} + +func (s *Primary_key_element_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPrimary_key_element_list(s) + } +} + +func (s *Primary_key_element_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPrimary_key_element_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Primary_key_element_list() (localctx IPrimary_key_element_listContext) { + localctx = NewPrimary_key_element_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 674, GoogleSQLParserRULE_primary_key_element_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4415) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4424) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-74)) & ^0x3f) == 0 && ((int64(1)<<(_la-74))&-106523215214079) != 0) || ((int64((_la-138)) & ^0x3f) == 0 && ((int64(1)<<(_la-138))&-1) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-36028797018963969) != 0) || ((int64((_la-266)) & ^0x3f) == 0 && ((int64(1)<<(_la-266))&536870911) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&33488865) != 0) { + { + p.SetState(4416) + p.Primary_key_element() + } + p.SetState(4421) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(4417) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4418) + p.Primary_key_element() + } + + p.SetState(4423) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(4426) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrimary_key_elementContext is an interface to support dynamic dispatch. +type IPrimary_key_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Asc_or_desc() IAsc_or_descContext + Null_order() INull_orderContext + + // IsPrimary_key_elementContext differentiates from other interfaces. + IsPrimary_key_elementContext() +} + +type Primary_key_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrimary_key_elementContext() *Primary_key_elementContext { + var p = new(Primary_key_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_primary_key_element + return p +} + +func InitEmptyPrimary_key_elementContext(p *Primary_key_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_primary_key_element +} + +func (*Primary_key_elementContext) IsPrimary_key_elementContext() {} + +func NewPrimary_key_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Primary_key_elementContext { + var p = new(Primary_key_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_primary_key_element + + return p +} + +func (s *Primary_key_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Primary_key_elementContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Primary_key_elementContext) Asc_or_desc() IAsc_or_descContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAsc_or_descContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAsc_or_descContext) +} + +func (s *Primary_key_elementContext) Null_order() INull_orderContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INull_orderContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INull_orderContext) +} + +func (s *Primary_key_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Primary_key_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Primary_key_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPrimary_key_element(s) + } +} + +func (s *Primary_key_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPrimary_key_element(s) + } +} + +func (s *Primary_key_elementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPrimary_key_element(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Primary_key_element() (localctx IPrimary_key_elementContext) { + localctx = NewPrimary_key_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 676, GoogleSQLParserRULE_primary_key_element) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4428) + p.Identifier() + } + p.SetState(4430) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserASC_SYMBOL || _la == GoogleSQLParserDESC_SYMBOL { + { + p.SetState(4429) + p.Asc_or_desc() + } + + } + p.SetState(4433) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserNULLS_SYMBOL { + { + p.SetState(4432) + p.Null_order() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_constraint_specContext is an interface to support dynamic dispatch. +type ITable_constraint_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHECK_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + Constraint_enforcement() IConstraint_enforcementContext + Opt_options_list() IOpt_options_listContext + FOREIGN_SYMBOL() antlr.TerminalNode + KEY_SYMBOL() antlr.TerminalNode + Column_list() IColumn_listContext + Foreign_key_reference() IForeign_key_referenceContext + + // IsTable_constraint_specContext differentiates from other interfaces. + IsTable_constraint_specContext() +} + +type Table_constraint_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_constraint_specContext() *Table_constraint_specContext { + var p = new(Table_constraint_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_constraint_spec + return p +} + +func InitEmptyTable_constraint_specContext(p *Table_constraint_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_constraint_spec +} + +func (*Table_constraint_specContext) IsTable_constraint_specContext() {} + +func NewTable_constraint_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_constraint_specContext { + var p = new(Table_constraint_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_table_constraint_spec + + return p +} + +func (s *Table_constraint_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_constraint_specContext) CHECK_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCHECK_SYMBOL, 0) +} + +func (s *Table_constraint_specContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Table_constraint_specContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Table_constraint_specContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Table_constraint_specContext) Constraint_enforcement() IConstraint_enforcementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_enforcementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_enforcementContext) +} + +func (s *Table_constraint_specContext) Opt_options_list() IOpt_options_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_options_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_options_listContext) +} + +func (s *Table_constraint_specContext) FOREIGN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFOREIGN_SYMBOL, 0) +} + +func (s *Table_constraint_specContext) KEY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserKEY_SYMBOL, 0) +} + +func (s *Table_constraint_specContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Table_constraint_specContext) Foreign_key_reference() IForeign_key_referenceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForeign_key_referenceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForeign_key_referenceContext) +} + +func (s *Table_constraint_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_constraint_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_constraint_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTable_constraint_spec(s) + } +} + +func (s *Table_constraint_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTable_constraint_spec(s) + } +} + +func (s *Table_constraint_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTable_constraint_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Table_constraint_spec() (localctx ITable_constraint_specContext) { + localctx = NewTable_constraint_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 678, GoogleSQLParserRULE_table_constraint_spec) + var _la int + + p.SetState(4455) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserCHECK_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4435) + p.Match(GoogleSQLParserCHECK_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4436) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4437) + p.expression(0) + } + { + p.SetState(4438) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4440) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserNOT_SYMBOL || _la == GoogleSQLParserENFORCED_SYMBOL { + { + p.SetState(4439) + p.Constraint_enforcement() + } + + } + p.SetState(4443) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(4442) + p.Opt_options_list() + } + + } + + case GoogleSQLParserFOREIGN_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4445) + p.Match(GoogleSQLParserFOREIGN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4446) + p.Match(GoogleSQLParserKEY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4447) + p.Column_list() + } + { + p.SetState(4448) + p.Foreign_key_reference() + } + p.SetState(4450) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserNOT_SYMBOL || _la == GoogleSQLParserENFORCED_SYMBOL { + { + p.SetState(4449) + p.Constraint_enforcement() + } + + } + p.SetState(4453) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOPTIONS_SYMBOL { + { + p.SetState(4452) + p.Opt_options_list() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IForeign_key_referenceContext is an interface to support dynamic dispatch. +type IForeign_key_referenceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REFERENCES_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + Column_list() IColumn_listContext + Opt_foreign_key_match() IOpt_foreign_key_matchContext + Opt_foreign_key_action() IOpt_foreign_key_actionContext + + // IsForeign_key_referenceContext differentiates from other interfaces. + IsForeign_key_referenceContext() +} + +type Foreign_key_referenceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyForeign_key_referenceContext() *Foreign_key_referenceContext { + var p = new(Foreign_key_referenceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_foreign_key_reference + return p +} + +func InitEmptyForeign_key_referenceContext(p *Foreign_key_referenceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_foreign_key_reference +} + +func (*Foreign_key_referenceContext) IsForeign_key_referenceContext() {} + +func NewForeign_key_referenceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Foreign_key_referenceContext { + var p = new(Foreign_key_referenceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_foreign_key_reference + + return p +} + +func (s *Foreign_key_referenceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Foreign_key_referenceContext) REFERENCES_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREFERENCES_SYMBOL, 0) +} + +func (s *Foreign_key_referenceContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Foreign_key_referenceContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Foreign_key_referenceContext) Opt_foreign_key_match() IOpt_foreign_key_matchContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_foreign_key_matchContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_foreign_key_matchContext) +} + +func (s *Foreign_key_referenceContext) Opt_foreign_key_action() IOpt_foreign_key_actionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_foreign_key_actionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_foreign_key_actionContext) +} + +func (s *Foreign_key_referenceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Foreign_key_referenceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Foreign_key_referenceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterForeign_key_reference(s) + } +} + +func (s *Foreign_key_referenceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitForeign_key_reference(s) + } +} + +func (s *Foreign_key_referenceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitForeign_key_reference(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Foreign_key_reference() (localctx IForeign_key_referenceContext) { + localctx = NewForeign_key_referenceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 680, GoogleSQLParserRULE_foreign_key_reference) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4457) + p.Match(GoogleSQLParserREFERENCES_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4458) + p.Path_expression() + } + { + p.SetState(4459) + p.Column_list() + } + p.SetState(4461) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserMATCH_SYMBOL { + { + p.SetState(4460) + p.Opt_foreign_key_match() + } + + } + p.SetState(4464) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserON_SYMBOL { + { + p.SetState(4463) + p.Opt_foreign_key_action() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_foreign_key_actionContext is an interface to support dynamic dispatch. +type IOpt_foreign_key_actionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Foreign_key_on_update() IForeign_key_on_updateContext + Foreign_key_on_delete() IForeign_key_on_deleteContext + + // IsOpt_foreign_key_actionContext differentiates from other interfaces. + IsOpt_foreign_key_actionContext() +} + +type Opt_foreign_key_actionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_foreign_key_actionContext() *Opt_foreign_key_actionContext { + var p = new(Opt_foreign_key_actionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_foreign_key_action + return p +} + +func InitEmptyOpt_foreign_key_actionContext(p *Opt_foreign_key_actionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_foreign_key_action +} + +func (*Opt_foreign_key_actionContext) IsOpt_foreign_key_actionContext() {} + +func NewOpt_foreign_key_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_foreign_key_actionContext { + var p = new(Opt_foreign_key_actionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_foreign_key_action + + return p +} + +func (s *Opt_foreign_key_actionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_foreign_key_actionContext) Foreign_key_on_update() IForeign_key_on_updateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForeign_key_on_updateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForeign_key_on_updateContext) +} + +func (s *Opt_foreign_key_actionContext) Foreign_key_on_delete() IForeign_key_on_deleteContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForeign_key_on_deleteContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForeign_key_on_deleteContext) +} + +func (s *Opt_foreign_key_actionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_foreign_key_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_foreign_key_actionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_foreign_key_action(s) + } +} + +func (s *Opt_foreign_key_actionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_foreign_key_action(s) + } +} + +func (s *Opt_foreign_key_actionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_foreign_key_action(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_foreign_key_action() (localctx IOpt_foreign_key_actionContext) { + localctx = NewOpt_foreign_key_actionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 682, GoogleSQLParserRULE_opt_foreign_key_action) + var _la int + + p.SetState(4474) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 537, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4466) + p.Foreign_key_on_update() + } + p.SetState(4468) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserON_SYMBOL { + { + p.SetState(4467) + p.Foreign_key_on_delete() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4470) + p.Foreign_key_on_delete() + } + p.SetState(4472) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserON_SYMBOL { + { + p.SetState(4471) + p.Foreign_key_on_update() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IForeign_key_on_updateContext is an interface to support dynamic dispatch. +type IForeign_key_on_updateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON_SYMBOL() antlr.TerminalNode + UPDATE_SYMBOL() antlr.TerminalNode + Foreign_key_action() IForeign_key_actionContext + + // IsForeign_key_on_updateContext differentiates from other interfaces. + IsForeign_key_on_updateContext() +} + +type Foreign_key_on_updateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyForeign_key_on_updateContext() *Foreign_key_on_updateContext { + var p = new(Foreign_key_on_updateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_foreign_key_on_update + return p +} + +func InitEmptyForeign_key_on_updateContext(p *Foreign_key_on_updateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_foreign_key_on_update +} + +func (*Foreign_key_on_updateContext) IsForeign_key_on_updateContext() {} + +func NewForeign_key_on_updateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Foreign_key_on_updateContext { + var p = new(Foreign_key_on_updateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_foreign_key_on_update + + return p +} + +func (s *Foreign_key_on_updateContext) GetParser() antlr.Parser { return s.parser } + +func (s *Foreign_key_on_updateContext) ON_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserON_SYMBOL, 0) +} + +func (s *Foreign_key_on_updateContext) UPDATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUPDATE_SYMBOL, 0) +} + +func (s *Foreign_key_on_updateContext) Foreign_key_action() IForeign_key_actionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForeign_key_actionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForeign_key_actionContext) +} + +func (s *Foreign_key_on_updateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Foreign_key_on_updateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Foreign_key_on_updateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterForeign_key_on_update(s) + } +} + +func (s *Foreign_key_on_updateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitForeign_key_on_update(s) + } +} + +func (s *Foreign_key_on_updateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitForeign_key_on_update(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Foreign_key_on_update() (localctx IForeign_key_on_updateContext) { + localctx = NewForeign_key_on_updateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 684, GoogleSQLParserRULE_foreign_key_on_update) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4476) + p.Match(GoogleSQLParserON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4477) + p.Match(GoogleSQLParserUPDATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4478) + p.Foreign_key_action() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IForeign_key_on_deleteContext is an interface to support dynamic dispatch. +type IForeign_key_on_deleteContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON_SYMBOL() antlr.TerminalNode + DELETE_SYMBOL() antlr.TerminalNode + Foreign_key_action() IForeign_key_actionContext + + // IsForeign_key_on_deleteContext differentiates from other interfaces. + IsForeign_key_on_deleteContext() +} + +type Foreign_key_on_deleteContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyForeign_key_on_deleteContext() *Foreign_key_on_deleteContext { + var p = new(Foreign_key_on_deleteContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_foreign_key_on_delete + return p +} + +func InitEmptyForeign_key_on_deleteContext(p *Foreign_key_on_deleteContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_foreign_key_on_delete +} + +func (*Foreign_key_on_deleteContext) IsForeign_key_on_deleteContext() {} + +func NewForeign_key_on_deleteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Foreign_key_on_deleteContext { + var p = new(Foreign_key_on_deleteContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_foreign_key_on_delete + + return p +} + +func (s *Foreign_key_on_deleteContext) GetParser() antlr.Parser { return s.parser } + +func (s *Foreign_key_on_deleteContext) ON_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserON_SYMBOL, 0) +} + +func (s *Foreign_key_on_deleteContext) DELETE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDELETE_SYMBOL, 0) +} + +func (s *Foreign_key_on_deleteContext) Foreign_key_action() IForeign_key_actionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForeign_key_actionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForeign_key_actionContext) +} + +func (s *Foreign_key_on_deleteContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Foreign_key_on_deleteContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Foreign_key_on_deleteContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterForeign_key_on_delete(s) + } +} + +func (s *Foreign_key_on_deleteContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitForeign_key_on_delete(s) + } +} + +func (s *Foreign_key_on_deleteContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitForeign_key_on_delete(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Foreign_key_on_delete() (localctx IForeign_key_on_deleteContext) { + localctx = NewForeign_key_on_deleteContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 686, GoogleSQLParserRULE_foreign_key_on_delete) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4480) + p.Match(GoogleSQLParserON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4481) + p.Match(GoogleSQLParserDELETE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4482) + p.Foreign_key_action() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IForeign_key_actionContext is an interface to support dynamic dispatch. +type IForeign_key_actionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NO_SYMBOL() antlr.TerminalNode + ACTION_SYMBOL() antlr.TerminalNode + RESTRICT_SYMBOL() antlr.TerminalNode + CASCADE_SYMBOL() antlr.TerminalNode + SET_SYMBOL() antlr.TerminalNode + NULL_SYMBOL() antlr.TerminalNode + + // IsForeign_key_actionContext differentiates from other interfaces. + IsForeign_key_actionContext() +} + +type Foreign_key_actionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyForeign_key_actionContext() *Foreign_key_actionContext { + var p = new(Foreign_key_actionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_foreign_key_action + return p +} + +func InitEmptyForeign_key_actionContext(p *Foreign_key_actionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_foreign_key_action +} + +func (*Foreign_key_actionContext) IsForeign_key_actionContext() {} + +func NewForeign_key_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Foreign_key_actionContext { + var p = new(Foreign_key_actionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_foreign_key_action + + return p +} + +func (s *Foreign_key_actionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Foreign_key_actionContext) NO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNO_SYMBOL, 0) +} + +func (s *Foreign_key_actionContext) ACTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserACTION_SYMBOL, 0) +} + +func (s *Foreign_key_actionContext) RESTRICT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRESTRICT_SYMBOL, 0) +} + +func (s *Foreign_key_actionContext) CASCADE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCASCADE_SYMBOL, 0) +} + +func (s *Foreign_key_actionContext) SET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSET_SYMBOL, 0) +} + +func (s *Foreign_key_actionContext) NULL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNULL_SYMBOL, 0) +} + +func (s *Foreign_key_actionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Foreign_key_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Foreign_key_actionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterForeign_key_action(s) + } +} + +func (s *Foreign_key_actionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitForeign_key_action(s) + } +} + +func (s *Foreign_key_actionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitForeign_key_action(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Foreign_key_action() (localctx IForeign_key_actionContext) { + localctx = NewForeign_key_actionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 688, GoogleSQLParserRULE_foreign_key_action) + p.SetState(4490) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserNO_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4484) + p.Match(GoogleSQLParserNO_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4485) + p.Match(GoogleSQLParserACTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserRESTRICT_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4486) + p.Match(GoogleSQLParserRESTRICT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserCASCADE_SYMBOL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4487) + p.Match(GoogleSQLParserCASCADE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserSET_SYMBOL: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4488) + p.Match(GoogleSQLParserSET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4489) + p.Match(GoogleSQLParserNULL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_foreign_key_matchContext is an interface to support dynamic dispatch. +type IOpt_foreign_key_matchContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MATCH_SYMBOL() antlr.TerminalNode + Foreign_key_match_mode() IForeign_key_match_modeContext + + // IsOpt_foreign_key_matchContext differentiates from other interfaces. + IsOpt_foreign_key_matchContext() +} + +type Opt_foreign_key_matchContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_foreign_key_matchContext() *Opt_foreign_key_matchContext { + var p = new(Opt_foreign_key_matchContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_foreign_key_match + return p +} + +func InitEmptyOpt_foreign_key_matchContext(p *Opt_foreign_key_matchContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_foreign_key_match +} + +func (*Opt_foreign_key_matchContext) IsOpt_foreign_key_matchContext() {} + +func NewOpt_foreign_key_matchContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_foreign_key_matchContext { + var p = new(Opt_foreign_key_matchContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_foreign_key_match + + return p +} + +func (s *Opt_foreign_key_matchContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_foreign_key_matchContext) MATCH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMATCH_SYMBOL, 0) +} + +func (s *Opt_foreign_key_matchContext) Foreign_key_match_mode() IForeign_key_match_modeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForeign_key_match_modeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForeign_key_match_modeContext) +} + +func (s *Opt_foreign_key_matchContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_foreign_key_matchContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_foreign_key_matchContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_foreign_key_match(s) + } +} + +func (s *Opt_foreign_key_matchContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_foreign_key_match(s) + } +} + +func (s *Opt_foreign_key_matchContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_foreign_key_match(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_foreign_key_match() (localctx IOpt_foreign_key_matchContext) { + localctx = NewOpt_foreign_key_matchContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 690, GoogleSQLParserRULE_opt_foreign_key_match) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4492) + p.Match(GoogleSQLParserMATCH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4493) + p.Foreign_key_match_mode() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IForeign_key_match_modeContext is an interface to support dynamic dispatch. +type IForeign_key_match_modeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SIMPLE_SYMBOL() antlr.TerminalNode + FULL_SYMBOL() antlr.TerminalNode + NOT_SYMBOL() antlr.TerminalNode + DISTINCT_SYMBOL() antlr.TerminalNode + + // IsForeign_key_match_modeContext differentiates from other interfaces. + IsForeign_key_match_modeContext() +} + +type Foreign_key_match_modeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyForeign_key_match_modeContext() *Foreign_key_match_modeContext { + var p = new(Foreign_key_match_modeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_foreign_key_match_mode + return p +} + +func InitEmptyForeign_key_match_modeContext(p *Foreign_key_match_modeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_foreign_key_match_mode +} + +func (*Foreign_key_match_modeContext) IsForeign_key_match_modeContext() {} + +func NewForeign_key_match_modeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Foreign_key_match_modeContext { + var p = new(Foreign_key_match_modeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_foreign_key_match_mode + + return p +} + +func (s *Foreign_key_match_modeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Foreign_key_match_modeContext) SIMPLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSIMPLE_SYMBOL, 0) +} + +func (s *Foreign_key_match_modeContext) FULL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFULL_SYMBOL, 0) +} + +func (s *Foreign_key_match_modeContext) NOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNOT_SYMBOL, 0) +} + +func (s *Foreign_key_match_modeContext) DISTINCT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDISTINCT_SYMBOL, 0) +} + +func (s *Foreign_key_match_modeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Foreign_key_match_modeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Foreign_key_match_modeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterForeign_key_match_mode(s) + } +} + +func (s *Foreign_key_match_modeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitForeign_key_match_mode(s) + } +} + +func (s *Foreign_key_match_modeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitForeign_key_match_mode(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Foreign_key_match_mode() (localctx IForeign_key_match_modeContext) { + localctx = NewForeign_key_match_modeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 692, GoogleSQLParserRULE_foreign_key_match_mode) + p.SetState(4499) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserSIMPLE_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4495) + p.Match(GoogleSQLParserSIMPLE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserFULL_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4496) + p.Match(GoogleSQLParserFULL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserNOT_SYMBOL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4497) + p.Match(GoogleSQLParserNOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4498) + p.Match(GoogleSQLParserDISTINCT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_listContext is an interface to support dynamic dispatch. +type IColumn_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsColumn_listContext differentiates from other interfaces. + IsColumn_listContext() +} + +type Column_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_listContext() *Column_listContext { + var p = new(Column_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_column_list + return p +} + +func InitEmptyColumn_listContext(p *Column_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_column_list +} + +func (*Column_listContext) IsColumn_listContext() {} + +func NewColumn_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_listContext { + var p = new(Column_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_column_list + + return p +} + +func (s *Column_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_listContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Column_listContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Column_listContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Column_listContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Column_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Column_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Column_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterColumn_list(s) + } +} + +func (s *Column_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitColumn_list(s) + } +} + +func (s *Column_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitColumn_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Column_list() (localctx IColumn_listContext) { + localctx = NewColumn_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 694, GoogleSQLParserRULE_column_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4501) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4502) + p.Identifier() + } + p.SetState(4507) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(4503) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4504) + p.Identifier() + } + + p.SetState(4509) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4510) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_options_listContext is an interface to support dynamic dispatch. +type IOpt_options_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPTIONS_SYMBOL() antlr.TerminalNode + Options_list() IOptions_listContext + + // IsOpt_options_listContext differentiates from other interfaces. + IsOpt_options_listContext() +} + +type Opt_options_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_options_listContext() *Opt_options_listContext { + var p = new(Opt_options_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_options_list + return p +} + +func InitEmptyOpt_options_listContext(p *Opt_options_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_options_list +} + +func (*Opt_options_listContext) IsOpt_options_listContext() {} + +func NewOpt_options_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_options_listContext { + var p = new(Opt_options_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_options_list + + return p +} + +func (s *Opt_options_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_options_listContext) OPTIONS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOPTIONS_SYMBOL, 0) +} + +func (s *Opt_options_listContext) Options_list() IOptions_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptions_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptions_listContext) +} + +func (s *Opt_options_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_options_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_options_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_options_list(s) + } +} + +func (s *Opt_options_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_options_list(s) + } +} + +func (s *Opt_options_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_options_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_options_list() (localctx IOpt_options_listContext) { + localctx = NewOpt_options_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 696, GoogleSQLParserRULE_opt_options_list) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4512) + p.Match(GoogleSQLParserOPTIONS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4513) + p.Options_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstraint_enforcementContext is an interface to support dynamic dispatch. +type IConstraint_enforcementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENFORCED_SYMBOL() antlr.TerminalNode + NOT_SYMBOL() antlr.TerminalNode + + // IsConstraint_enforcementContext differentiates from other interfaces. + IsConstraint_enforcementContext() +} + +type Constraint_enforcementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstraint_enforcementContext() *Constraint_enforcementContext { + var p = new(Constraint_enforcementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_constraint_enforcement + return p +} + +func InitEmptyConstraint_enforcementContext(p *Constraint_enforcementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_constraint_enforcement +} + +func (*Constraint_enforcementContext) IsConstraint_enforcementContext() {} + +func NewConstraint_enforcementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Constraint_enforcementContext { + var p = new(Constraint_enforcementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_constraint_enforcement + + return p +} + +func (s *Constraint_enforcementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Constraint_enforcementContext) ENFORCED_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserENFORCED_SYMBOL, 0) +} + +func (s *Constraint_enforcementContext) NOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNOT_SYMBOL, 0) +} + +func (s *Constraint_enforcementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Constraint_enforcementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Constraint_enforcementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterConstraint_enforcement(s) + } +} + +func (s *Constraint_enforcementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitConstraint_enforcement(s) + } +} + +func (s *Constraint_enforcementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitConstraint_enforcement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Constraint_enforcement() (localctx IConstraint_enforcementContext) { + localctx = NewConstraint_enforcementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 698, GoogleSQLParserRULE_constraint_enforcement) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4516) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserNOT_SYMBOL { + { + p.SetState(4515) + p.Match(GoogleSQLParserNOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4518) + p.Match(GoogleSQLParserENFORCED_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGeneric_entity_bodyContext is an interface to support dynamic dispatch. +type IGeneric_entity_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Json_literal() IJson_literalContext + String_literal() IString_literalContext + + // IsGeneric_entity_bodyContext differentiates from other interfaces. + IsGeneric_entity_bodyContext() +} + +type Generic_entity_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGeneric_entity_bodyContext() *Generic_entity_bodyContext { + var p = new(Generic_entity_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_generic_entity_body + return p +} + +func InitEmptyGeneric_entity_bodyContext(p *Generic_entity_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_generic_entity_body +} + +func (*Generic_entity_bodyContext) IsGeneric_entity_bodyContext() {} + +func NewGeneric_entity_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generic_entity_bodyContext { + var p = new(Generic_entity_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_generic_entity_body + + return p +} + +func (s *Generic_entity_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Generic_entity_bodyContext) Json_literal() IJson_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_literalContext) +} + +func (s *Generic_entity_bodyContext) String_literal() IString_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_literalContext) +} + +func (s *Generic_entity_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Generic_entity_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Generic_entity_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGeneric_entity_body(s) + } +} + +func (s *Generic_entity_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGeneric_entity_body(s) + } +} + +func (s *Generic_entity_bodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGeneric_entity_body(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Generic_entity_body() (localctx IGeneric_entity_bodyContext) { + localctx = NewGeneric_entity_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 700, GoogleSQLParserRULE_generic_entity_body) + p.SetState(4522) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserJSON_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4520) + p.Json_literal() + } + + case GoogleSQLParserSTRING_LITERAL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4521) + p.string_literal(0) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_if_existsContext is an interface to support dynamic dispatch. +type IOpt_if_existsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IF_SYMBOL() antlr.TerminalNode + EXISTS_SYMBOL() antlr.TerminalNode + + // IsOpt_if_existsContext differentiates from other interfaces. + IsOpt_if_existsContext() +} + +type Opt_if_existsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_if_existsContext() *Opt_if_existsContext { + var p = new(Opt_if_existsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_if_exists + return p +} + +func InitEmptyOpt_if_existsContext(p *Opt_if_existsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_if_exists +} + +func (*Opt_if_existsContext) IsOpt_if_existsContext() {} + +func NewOpt_if_existsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_if_existsContext { + var p = new(Opt_if_existsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_if_exists + + return p +} + +func (s *Opt_if_existsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_if_existsContext) IF_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIF_SYMBOL, 0) +} + +func (s *Opt_if_existsContext) EXISTS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXISTS_SYMBOL, 0) +} + +func (s *Opt_if_existsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_if_existsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_if_existsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_if_exists(s) + } +} + +func (s *Opt_if_existsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_if_exists(s) + } +} + +func (s *Opt_if_existsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_if_exists(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_if_exists() (localctx IOpt_if_existsContext) { + localctx = NewOpt_if_existsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 702, GoogleSQLParserRULE_opt_if_exists) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4524) + p.Match(GoogleSQLParserIF_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4525) + p.Match(GoogleSQLParserEXISTS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_or_table_functionContext is an interface to support dynamic dispatch. +type ITable_or_table_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLE_SYMBOL() antlr.TerminalNode + FUNCTION_SYMBOL() antlr.TerminalNode + + // IsTable_or_table_functionContext differentiates from other interfaces. + IsTable_or_table_functionContext() +} + +type Table_or_table_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_or_table_functionContext() *Table_or_table_functionContext { + var p = new(Table_or_table_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_or_table_function + return p +} + +func InitEmptyTable_or_table_functionContext(p *Table_or_table_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_or_table_function +} + +func (*Table_or_table_functionContext) IsTable_or_table_functionContext() {} + +func NewTable_or_table_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_or_table_functionContext { + var p = new(Table_or_table_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_table_or_table_function + + return p +} + +func (s *Table_or_table_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_or_table_functionContext) TABLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTABLE_SYMBOL, 0) +} + +func (s *Table_or_table_functionContext) FUNCTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFUNCTION_SYMBOL, 0) +} + +func (s *Table_or_table_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_or_table_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_or_table_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTable_or_table_function(s) + } +} + +func (s *Table_or_table_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTable_or_table_function(s) + } +} + +func (s *Table_or_table_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTable_or_table_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Table_or_table_function() (localctx ITable_or_table_functionContext) { + localctx = NewTable_or_table_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 704, GoogleSQLParserRULE_table_or_table_function) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4527) + p.Match(GoogleSQLParserTABLE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4529) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 543, p.GetParserRuleContext()) == 1 { + { + p.SetState(4528) + p.Match(GoogleSQLParserFUNCTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQueryContext is an interface to support dynamic dispatch. +type IQueryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Query_without_pipe_operators() IQuery_without_pipe_operatorsContext + + // IsQueryContext differentiates from other interfaces. + IsQueryContext() +} + +type QueryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQueryContext() *QueryContext { + var p = new(QueryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_query + return p +} + +func InitEmptyQueryContext(p *QueryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_query +} + +func (*QueryContext) IsQueryContext() {} + +func NewQueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QueryContext { + var p = new(QueryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_query + + return p +} + +func (s *QueryContext) GetParser() antlr.Parser { return s.parser } + +func (s *QueryContext) Query_without_pipe_operators() IQuery_without_pipe_operatorsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_without_pipe_operatorsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_without_pipe_operatorsContext) +} + +func (s *QueryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *QueryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *QueryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterQuery(s) + } +} + +func (s *QueryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitQuery(s) + } +} + +func (s *QueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitQuery(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Query() (localctx IQueryContext) { + localctx = NewQueryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 706, GoogleSQLParserRULE_query) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4531) + p.Query_without_pipe_operators() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuery_without_pipe_operatorsContext is an interface to support dynamic dispatch. +type IQuery_without_pipe_operatorsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + With_clause() IWith_clauseContext + Query_primary_or_set_operation() IQuery_primary_or_set_operationContext + Order_by_clause() IOrder_by_clauseContext + Limit_offset_clause() ILimit_offset_clauseContext + With_clause_with_trailing_comma() IWith_clause_with_trailing_commaContext + Select_or_from_keyword() ISelect_or_from_keywordContext + PIPE_SYMBOL() antlr.TerminalNode + From_clause() IFrom_clauseContext + Bad_keyword_after_from_query() IBad_keyword_after_from_queryContext + Bad_keyword_after_from_query_allows_parens() IBad_keyword_after_from_query_allows_parensContext + + // IsQuery_without_pipe_operatorsContext differentiates from other interfaces. + IsQuery_without_pipe_operatorsContext() +} + +type Query_without_pipe_operatorsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuery_without_pipe_operatorsContext() *Query_without_pipe_operatorsContext { + var p = new(Query_without_pipe_operatorsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_query_without_pipe_operators + return p +} + +func InitEmptyQuery_without_pipe_operatorsContext(p *Query_without_pipe_operatorsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_query_without_pipe_operators +} + +func (*Query_without_pipe_operatorsContext) IsQuery_without_pipe_operatorsContext() {} + +func NewQuery_without_pipe_operatorsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_without_pipe_operatorsContext { + var p = new(Query_without_pipe_operatorsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_query_without_pipe_operators + + return p +} + +func (s *Query_without_pipe_operatorsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Query_without_pipe_operatorsContext) With_clause() IWith_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_clauseContext) +} + +func (s *Query_without_pipe_operatorsContext) Query_primary_or_set_operation() IQuery_primary_or_set_operationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_primary_or_set_operationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_primary_or_set_operationContext) +} + +func (s *Query_without_pipe_operatorsContext) Order_by_clause() IOrder_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_clauseContext) +} + +func (s *Query_without_pipe_operatorsContext) Limit_offset_clause() ILimit_offset_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimit_offset_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimit_offset_clauseContext) +} + +func (s *Query_without_pipe_operatorsContext) With_clause_with_trailing_comma() IWith_clause_with_trailing_commaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_clause_with_trailing_commaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_clause_with_trailing_commaContext) +} + +func (s *Query_without_pipe_operatorsContext) Select_or_from_keyword() ISelect_or_from_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_or_from_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_or_from_keywordContext) +} + +func (s *Query_without_pipe_operatorsContext) PIPE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPIPE_SYMBOL, 0) +} + +func (s *Query_without_pipe_operatorsContext) From_clause() IFrom_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrom_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrom_clauseContext) +} + +func (s *Query_without_pipe_operatorsContext) Bad_keyword_after_from_query() IBad_keyword_after_from_queryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBad_keyword_after_from_queryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBad_keyword_after_from_queryContext) +} + +func (s *Query_without_pipe_operatorsContext) Bad_keyword_after_from_query_allows_parens() IBad_keyword_after_from_query_allows_parensContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBad_keyword_after_from_query_allows_parensContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBad_keyword_after_from_query_allows_parensContext) +} + +func (s *Query_without_pipe_operatorsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Query_without_pipe_operatorsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Query_without_pipe_operatorsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterQuery_without_pipe_operators(s) + } +} + +func (s *Query_without_pipe_operatorsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitQuery_without_pipe_operators(s) + } +} + +func (s *Query_without_pipe_operatorsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitQuery_without_pipe_operators(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Query_without_pipe_operators() (localctx IQuery_without_pipe_operatorsContext) { + localctx = NewQuery_without_pipe_operatorsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 708, GoogleSQLParserRULE_query_without_pipe_operators) + var _la int + + p.SetState(4576) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 551, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4533) + p.With_clause() + } + { + p.SetState(4534) + p.Query_primary_or_set_operation() + } + p.SetState(4536) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserORDER_SYMBOL { + { + p.SetState(4535) + p.Order_by_clause() + } + + } + p.SetState(4539) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLIMIT_SYMBOL { + { + p.SetState(4538) + p.Limit_offset_clause() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4541) + p.With_clause_with_trailing_comma() + } + { + p.SetState(4542) + p.Select_or_from_keyword() + } + p.NotifyErrorListeners("Syntax error: Trailing comma after the WITH clause before the main query is not allowed", nil, nil) + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4545) + p.With_clause() + } + { + p.SetState(4546) + p.Match(GoogleSQLParserPIPE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.NotifyErrorListeners("Syntax error: A pipe operator cannot follow the WITH clause before the main query; The main query usually starts with SELECT or FROM here", nil, nil) + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4549) + p.Query_primary_or_set_operation() + } + p.SetState(4551) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserORDER_SYMBOL { + { + p.SetState(4550) + p.Order_by_clause() + } + + } + p.SetState(4554) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLIMIT_SYMBOL { + { + p.SetState(4553) + p.Limit_offset_clause() + } + + } + + case 5: + p.EnterOuterAlt(localctx, 5) + p.SetState(4557) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWITH_SYMBOL { + { + p.SetState(4556) + p.With_clause() + } + + } + { + p.SetState(4559) + p.From_clause() + } + p.NotifyErrorListeners("Syntax error: Unexpected FROM", nil, nil) + + case 6: + p.EnterOuterAlt(localctx, 6) + p.SetState(4563) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWITH_SYMBOL { + { + p.SetState(4562) + p.With_clause() + } + + } + { + p.SetState(4565) + p.From_clause() + } + { + p.SetState(4566) + p.Bad_keyword_after_from_query() + } + p.NotifyErrorListeners("Syntax error: not supported after FROM query; Consider using pipe operator `|>` ", nil, nil) + + case 7: + p.EnterOuterAlt(localctx, 7) + p.SetState(4570) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWITH_SYMBOL { + { + p.SetState(4569) + p.With_clause() + } + + } + { + p.SetState(4572) + p.From_clause() + } + { + p.SetState(4573) + p.Bad_keyword_after_from_query_allows_parens() + } + p.NotifyErrorListeners("Syntax error: not supported after FROM query; Consider using pipe operator `|>` ", nil, nil) + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBad_keyword_after_from_queryContext is an interface to support dynamic dispatch. +type IBad_keyword_after_from_queryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHERE_SYMBOL() antlr.TerminalNode + SELECT_SYMBOL() antlr.TerminalNode + GROUP_SYMBOL() antlr.TerminalNode + + // IsBad_keyword_after_from_queryContext differentiates from other interfaces. + IsBad_keyword_after_from_queryContext() +} + +type Bad_keyword_after_from_queryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBad_keyword_after_from_queryContext() *Bad_keyword_after_from_queryContext { + var p = new(Bad_keyword_after_from_queryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_bad_keyword_after_from_query + return p +} + +func InitEmptyBad_keyword_after_from_queryContext(p *Bad_keyword_after_from_queryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_bad_keyword_after_from_query +} + +func (*Bad_keyword_after_from_queryContext) IsBad_keyword_after_from_queryContext() {} + +func NewBad_keyword_after_from_queryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Bad_keyword_after_from_queryContext { + var p = new(Bad_keyword_after_from_queryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_bad_keyword_after_from_query + + return p +} + +func (s *Bad_keyword_after_from_queryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Bad_keyword_after_from_queryContext) WHERE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWHERE_SYMBOL, 0) +} + +func (s *Bad_keyword_after_from_queryContext) SELECT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSELECT_SYMBOL, 0) +} + +func (s *Bad_keyword_after_from_queryContext) GROUP_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserGROUP_SYMBOL, 0) +} + +func (s *Bad_keyword_after_from_queryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Bad_keyword_after_from_queryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Bad_keyword_after_from_queryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterBad_keyword_after_from_query(s) + } +} + +func (s *Bad_keyword_after_from_queryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitBad_keyword_after_from_query(s) + } +} + +func (s *Bad_keyword_after_from_queryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitBad_keyword_after_from_query(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Bad_keyword_after_from_query() (localctx IBad_keyword_after_from_queryContext) { + localctx = NewBad_keyword_after_from_queryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 710, GoogleSQLParserRULE_bad_keyword_after_from_query) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4578) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserSELECT_SYMBOL || _la == GoogleSQLParserGROUP_SYMBOL || _la == GoogleSQLParserWHERE_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBad_keyword_after_from_query_allows_parensContext is an interface to support dynamic dispatch. +type IBad_keyword_after_from_query_allows_parensContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ORDER_SYMBOL() antlr.TerminalNode + UNION_SYMBOL() antlr.TerminalNode + INTERSECT_SYMBOL() antlr.TerminalNode + EXCEPT_SYMBOL() antlr.TerminalNode + LIMIT_SYMBOL() antlr.TerminalNode + + // IsBad_keyword_after_from_query_allows_parensContext differentiates from other interfaces. + IsBad_keyword_after_from_query_allows_parensContext() +} + +type Bad_keyword_after_from_query_allows_parensContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBad_keyword_after_from_query_allows_parensContext() *Bad_keyword_after_from_query_allows_parensContext { + var p = new(Bad_keyword_after_from_query_allows_parensContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_bad_keyword_after_from_query_allows_parens + return p +} + +func InitEmptyBad_keyword_after_from_query_allows_parensContext(p *Bad_keyword_after_from_query_allows_parensContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_bad_keyword_after_from_query_allows_parens +} + +func (*Bad_keyword_after_from_query_allows_parensContext) IsBad_keyword_after_from_query_allows_parensContext() { +} + +func NewBad_keyword_after_from_query_allows_parensContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Bad_keyword_after_from_query_allows_parensContext { + var p = new(Bad_keyword_after_from_query_allows_parensContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_bad_keyword_after_from_query_allows_parens + + return p +} + +func (s *Bad_keyword_after_from_query_allows_parensContext) GetParser() antlr.Parser { return s.parser } + +func (s *Bad_keyword_after_from_query_allows_parensContext) ORDER_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserORDER_SYMBOL, 0) +} + +func (s *Bad_keyword_after_from_query_allows_parensContext) UNION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUNION_SYMBOL, 0) +} + +func (s *Bad_keyword_after_from_query_allows_parensContext) INTERSECT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINTERSECT_SYMBOL, 0) +} + +func (s *Bad_keyword_after_from_query_allows_parensContext) EXCEPT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXCEPT_SYMBOL, 0) +} + +func (s *Bad_keyword_after_from_query_allows_parensContext) LIMIT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLIMIT_SYMBOL, 0) +} + +func (s *Bad_keyword_after_from_query_allows_parensContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Bad_keyword_after_from_query_allows_parensContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Bad_keyword_after_from_query_allows_parensContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterBad_keyword_after_from_query_allows_parens(s) + } +} + +func (s *Bad_keyword_after_from_query_allows_parensContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitBad_keyword_after_from_query_allows_parens(s) + } +} + +func (s *Bad_keyword_after_from_query_allows_parensContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitBad_keyword_after_from_query_allows_parens(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Bad_keyword_after_from_query_allows_parens() (localctx IBad_keyword_after_from_query_allows_parensContext) { + localctx = NewBad_keyword_after_from_query_allows_parensContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 712, GoogleSQLParserRULE_bad_keyword_after_from_query_allows_parens) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4580) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-68)) & ^0x3f) == 0 && ((int64(1)<<(_la-68))&4295230721) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWith_clause_with_trailing_commaContext is an interface to support dynamic dispatch. +type IWith_clause_with_trailing_commaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + With_clause() IWith_clauseContext + COMMA_SYMBOL() antlr.TerminalNode + + // IsWith_clause_with_trailing_commaContext differentiates from other interfaces. + IsWith_clause_with_trailing_commaContext() +} + +type With_clause_with_trailing_commaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWith_clause_with_trailing_commaContext() *With_clause_with_trailing_commaContext { + var p = new(With_clause_with_trailing_commaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_with_clause_with_trailing_comma + return p +} + +func InitEmptyWith_clause_with_trailing_commaContext(p *With_clause_with_trailing_commaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_with_clause_with_trailing_comma +} + +func (*With_clause_with_trailing_commaContext) IsWith_clause_with_trailing_commaContext() {} + +func NewWith_clause_with_trailing_commaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_clause_with_trailing_commaContext { + var p = new(With_clause_with_trailing_commaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_with_clause_with_trailing_comma + + return p +} + +func (s *With_clause_with_trailing_commaContext) GetParser() antlr.Parser { return s.parser } + +func (s *With_clause_with_trailing_commaContext) With_clause() IWith_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_clauseContext) +} + +func (s *With_clause_with_trailing_commaContext) COMMA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, 0) +} + +func (s *With_clause_with_trailing_commaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *With_clause_with_trailing_commaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *With_clause_with_trailing_commaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterWith_clause_with_trailing_comma(s) + } +} + +func (s *With_clause_with_trailing_commaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitWith_clause_with_trailing_comma(s) + } +} + +func (s *With_clause_with_trailing_commaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitWith_clause_with_trailing_comma(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) With_clause_with_trailing_comma() (localctx IWith_clause_with_trailing_commaContext) { + localctx = NewWith_clause_with_trailing_commaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 714, GoogleSQLParserRULE_with_clause_with_trailing_comma) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4582) + p.With_clause() + } + { + p.SetState(4583) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_or_from_keywordContext is an interface to support dynamic dispatch. +type ISelect_or_from_keywordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SELECT_SYMBOL() antlr.TerminalNode + FROM_SYMBOL() antlr.TerminalNode + + // IsSelect_or_from_keywordContext differentiates from other interfaces. + IsSelect_or_from_keywordContext() +} + +type Select_or_from_keywordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_or_from_keywordContext() *Select_or_from_keywordContext { + var p = new(Select_or_from_keywordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_select_or_from_keyword + return p +} + +func InitEmptySelect_or_from_keywordContext(p *Select_or_from_keywordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_select_or_from_keyword +} + +func (*Select_or_from_keywordContext) IsSelect_or_from_keywordContext() {} + +func NewSelect_or_from_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_or_from_keywordContext { + var p = new(Select_or_from_keywordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_select_or_from_keyword + + return p +} + +func (s *Select_or_from_keywordContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_or_from_keywordContext) SELECT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSELECT_SYMBOL, 0) +} + +func (s *Select_or_from_keywordContext) FROM_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFROM_SYMBOL, 0) +} + +func (s *Select_or_from_keywordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_or_from_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_or_from_keywordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSelect_or_from_keyword(s) + } +} + +func (s *Select_or_from_keywordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSelect_or_from_keyword(s) + } +} + +func (s *Select_or_from_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSelect_or_from_keyword(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Select_or_from_keyword() (localctx ISelect_or_from_keywordContext) { + localctx = NewSelect_or_from_keywordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 716, GoogleSQLParserRULE_select_or_from_keyword) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4585) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserFROM_SYMBOL || _la == GoogleSQLParserSELECT_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuery_primary_or_set_operationContext is an interface to support dynamic dispatch. +type IQuery_primary_or_set_operationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Query_primary() IQuery_primaryContext + Query_set_operation() IQuery_set_operationContext + + // IsQuery_primary_or_set_operationContext differentiates from other interfaces. + IsQuery_primary_or_set_operationContext() +} + +type Query_primary_or_set_operationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuery_primary_or_set_operationContext() *Query_primary_or_set_operationContext { + var p = new(Query_primary_or_set_operationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_query_primary_or_set_operation + return p +} + +func InitEmptyQuery_primary_or_set_operationContext(p *Query_primary_or_set_operationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_query_primary_or_set_operation +} + +func (*Query_primary_or_set_operationContext) IsQuery_primary_or_set_operationContext() {} + +func NewQuery_primary_or_set_operationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_primary_or_set_operationContext { + var p = new(Query_primary_or_set_operationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_query_primary_or_set_operation + + return p +} + +func (s *Query_primary_or_set_operationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Query_primary_or_set_operationContext) Query_primary() IQuery_primaryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_primaryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_primaryContext) +} + +func (s *Query_primary_or_set_operationContext) Query_set_operation() IQuery_set_operationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_set_operationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_set_operationContext) +} + +func (s *Query_primary_or_set_operationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Query_primary_or_set_operationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Query_primary_or_set_operationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterQuery_primary_or_set_operation(s) + } +} + +func (s *Query_primary_or_set_operationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitQuery_primary_or_set_operation(s) + } +} + +func (s *Query_primary_or_set_operationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitQuery_primary_or_set_operation(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Query_primary_or_set_operation() (localctx IQuery_primary_or_set_operationContext) { + localctx = NewQuery_primary_or_set_operationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 718, GoogleSQLParserRULE_query_primary_or_set_operation) + p.SetState(4589) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 552, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4587) + p.Query_primary() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4588) + p.Query_set_operation() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuery_set_operationContext is an interface to support dynamic dispatch. +type IQuery_set_operationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Query_set_operation_prefix() IQuery_set_operation_prefixContext + + // IsQuery_set_operationContext differentiates from other interfaces. + IsQuery_set_operationContext() +} + +type Query_set_operationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuery_set_operationContext() *Query_set_operationContext { + var p = new(Query_set_operationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_query_set_operation + return p +} + +func InitEmptyQuery_set_operationContext(p *Query_set_operationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_query_set_operation +} + +func (*Query_set_operationContext) IsQuery_set_operationContext() {} + +func NewQuery_set_operationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_set_operationContext { + var p = new(Query_set_operationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_query_set_operation + + return p +} + +func (s *Query_set_operationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Query_set_operationContext) Query_set_operation_prefix() IQuery_set_operation_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_set_operation_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_set_operation_prefixContext) +} + +func (s *Query_set_operationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Query_set_operationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Query_set_operationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterQuery_set_operation(s) + } +} + +func (s *Query_set_operationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitQuery_set_operation(s) + } +} + +func (s *Query_set_operationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitQuery_set_operation(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Query_set_operation() (localctx IQuery_set_operationContext) { + localctx = NewQuery_set_operationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 720, GoogleSQLParserRULE_query_set_operation) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4591) + p.query_set_operation_prefix(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuery_set_operation_prefixContext is an interface to support dynamic dispatch. +type IQuery_set_operation_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Query_primary() IQuery_primaryContext + AllQuery_set_operation_item() []IQuery_set_operation_itemContext + Query_set_operation_item(i int) IQuery_set_operation_itemContext + Set_operation_metadata() ISet_operation_metadataContext + FROM_SYMBOL() antlr.TerminalNode + Query_set_operation_prefix() IQuery_set_operation_prefixContext + + // IsQuery_set_operation_prefixContext differentiates from other interfaces. + IsQuery_set_operation_prefixContext() +} + +type Query_set_operation_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuery_set_operation_prefixContext() *Query_set_operation_prefixContext { + var p = new(Query_set_operation_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_query_set_operation_prefix + return p +} + +func InitEmptyQuery_set_operation_prefixContext(p *Query_set_operation_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_query_set_operation_prefix +} + +func (*Query_set_operation_prefixContext) IsQuery_set_operation_prefixContext() {} + +func NewQuery_set_operation_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_set_operation_prefixContext { + var p = new(Query_set_operation_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_query_set_operation_prefix + + return p +} + +func (s *Query_set_operation_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Query_set_operation_prefixContext) Query_primary() IQuery_primaryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_primaryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_primaryContext) +} + +func (s *Query_set_operation_prefixContext) AllQuery_set_operation_item() []IQuery_set_operation_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuery_set_operation_itemContext); ok { + len++ + } + } + + tst := make([]IQuery_set_operation_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuery_set_operation_itemContext); ok { + tst[i] = t.(IQuery_set_operation_itemContext) + i++ + } + } + + return tst +} + +func (s *Query_set_operation_prefixContext) Query_set_operation_item(i int) IQuery_set_operation_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_set_operation_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuery_set_operation_itemContext) +} + +func (s *Query_set_operation_prefixContext) Set_operation_metadata() ISet_operation_metadataContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_operation_metadataContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_operation_metadataContext) +} + +func (s *Query_set_operation_prefixContext) FROM_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFROM_SYMBOL, 0) +} + +func (s *Query_set_operation_prefixContext) Query_set_operation_prefix() IQuery_set_operation_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_set_operation_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_set_operation_prefixContext) +} + +func (s *Query_set_operation_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Query_set_operation_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Query_set_operation_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterQuery_set_operation_prefix(s) + } +} + +func (s *Query_set_operation_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitQuery_set_operation_prefix(s) + } +} + +func (s *Query_set_operation_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitQuery_set_operation_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Query_set_operation_prefix() (localctx IQuery_set_operation_prefixContext) { + return p.query_set_operation_prefix(0) +} + +func (p *GoogleSQLParser) query_set_operation_prefix(_p int) (localctx IQuery_set_operation_prefixContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewQuery_set_operation_prefixContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IQuery_set_operation_prefixContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 722 + p.EnterRecursionRule(localctx, 722, GoogleSQLParserRULE_query_set_operation_prefix, _p) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4605) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 554, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4594) + p.Query_primary() + } + p.SetState(4596) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(4595) + p.Query_set_operation_item() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(4598) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 553, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + { + p.SetState(4600) + p.Query_primary() + } + { + p.SetState(4601) + p.Set_operation_metadata() + } + { + p.SetState(4602) + p.Match(GoogleSQLParserFROM_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.NotifyErrorListeners("Syntax error: Unexpected FROM;FROM queries following a set operation must be parenthesized", nil, nil) + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(4614) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 555, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + localctx = NewQuery_set_operation_prefixContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_query_set_operation_prefix) + p.SetState(4607) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(4608) + p.Set_operation_metadata() + } + { + p.SetState(4609) + p.Match(GoogleSQLParserFROM_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.NotifyErrorListeners("Syntax error: Unexpected FROM;FROM queries following a set operation must be parenthesized", nil, nil) + + } + p.SetState(4616) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 555, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuery_set_operation_itemContext is an interface to support dynamic dispatch. +type IQuery_set_operation_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Set_operation_metadata() ISet_operation_metadataContext + Query_primary() IQuery_primaryContext + + // IsQuery_set_operation_itemContext differentiates from other interfaces. + IsQuery_set_operation_itemContext() +} + +type Query_set_operation_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuery_set_operation_itemContext() *Query_set_operation_itemContext { + var p = new(Query_set_operation_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_query_set_operation_item + return p +} + +func InitEmptyQuery_set_operation_itemContext(p *Query_set_operation_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_query_set_operation_item +} + +func (*Query_set_operation_itemContext) IsQuery_set_operation_itemContext() {} + +func NewQuery_set_operation_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_set_operation_itemContext { + var p = new(Query_set_operation_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_query_set_operation_item + + return p +} + +func (s *Query_set_operation_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Query_set_operation_itemContext) Set_operation_metadata() ISet_operation_metadataContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_operation_metadataContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_operation_metadataContext) +} + +func (s *Query_set_operation_itemContext) Query_primary() IQuery_primaryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_primaryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_primaryContext) +} + +func (s *Query_set_operation_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Query_set_operation_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Query_set_operation_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterQuery_set_operation_item(s) + } +} + +func (s *Query_set_operation_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitQuery_set_operation_item(s) + } +} + +func (s *Query_set_operation_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitQuery_set_operation_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Query_set_operation_item() (localctx IQuery_set_operation_itemContext) { + localctx = NewQuery_set_operation_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 724, GoogleSQLParserRULE_query_set_operation_item) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4617) + p.Set_operation_metadata() + } + { + p.SetState(4618) + p.Query_primary() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuery_primaryContext is an interface to support dynamic dispatch. +type IQuery_primaryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Select_() ISelectContext + Parenthesized_query() IParenthesized_queryContext + Opt_as_alias_with_required_as() IOpt_as_alias_with_required_asContext + + // IsQuery_primaryContext differentiates from other interfaces. + IsQuery_primaryContext() +} + +type Query_primaryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuery_primaryContext() *Query_primaryContext { + var p = new(Query_primaryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_query_primary + return p +} + +func InitEmptyQuery_primaryContext(p *Query_primaryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_query_primary +} + +func (*Query_primaryContext) IsQuery_primaryContext() {} + +func NewQuery_primaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_primaryContext { + var p = new(Query_primaryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_query_primary + + return p +} + +func (s *Query_primaryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Query_primaryContext) Select_() ISelectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectContext) +} + +func (s *Query_primaryContext) Parenthesized_query() IParenthesized_queryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesized_queryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParenthesized_queryContext) +} + +func (s *Query_primaryContext) Opt_as_alias_with_required_as() IOpt_as_alias_with_required_asContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_as_alias_with_required_asContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_as_alias_with_required_asContext) +} + +func (s *Query_primaryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Query_primaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Query_primaryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterQuery_primary(s) + } +} + +func (s *Query_primaryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitQuery_primary(s) + } +} + +func (s *Query_primaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitQuery_primary(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Query_primary() (localctx IQuery_primaryContext) { + localctx = NewQuery_primaryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 726, GoogleSQLParserRULE_query_primary) + p.SetState(4625) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserSELECT_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4620) + p.Select_() + } + + case GoogleSQLParserLR_BRACKET_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4621) + p.Parenthesized_query() + } + p.SetState(4623) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 556, p.GetParserRuleContext()) == 1 { + { + p.SetState(4622) + p.Opt_as_alias_with_required_as() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISet_operation_metadataContext is an interface to support dynamic dispatch. +type ISet_operation_metadataContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Query_set_operation_type() IQuery_set_operation_typeContext + All_or_distinct() IAll_or_distinctContext + Opt_corresponding_outer_mode() IOpt_corresponding_outer_modeContext + Hint() IHintContext + Opt_strict() IOpt_strictContext + Opt_column_match_suffix() IOpt_column_match_suffixContext + + // IsSet_operation_metadataContext differentiates from other interfaces. + IsSet_operation_metadataContext() +} + +type Set_operation_metadataContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_operation_metadataContext() *Set_operation_metadataContext { + var p = new(Set_operation_metadataContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_set_operation_metadata + return p +} + +func InitEmptySet_operation_metadataContext(p *Set_operation_metadataContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_set_operation_metadata +} + +func (*Set_operation_metadataContext) IsSet_operation_metadataContext() {} + +func NewSet_operation_metadataContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_operation_metadataContext { + var p = new(Set_operation_metadataContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_set_operation_metadata + + return p +} + +func (s *Set_operation_metadataContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_operation_metadataContext) Query_set_operation_type() IQuery_set_operation_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_set_operation_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_set_operation_typeContext) +} + +func (s *Set_operation_metadataContext) All_or_distinct() IAll_or_distinctContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_or_distinctContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_or_distinctContext) +} + +func (s *Set_operation_metadataContext) Opt_corresponding_outer_mode() IOpt_corresponding_outer_modeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_corresponding_outer_modeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_corresponding_outer_modeContext) +} + +func (s *Set_operation_metadataContext) Hint() IHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Set_operation_metadataContext) Opt_strict() IOpt_strictContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_strictContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_strictContext) +} + +func (s *Set_operation_metadataContext) Opt_column_match_suffix() IOpt_column_match_suffixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_column_match_suffixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_column_match_suffixContext) +} + +func (s *Set_operation_metadataContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_operation_metadataContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_operation_metadataContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSet_operation_metadata(s) + } +} + +func (s *Set_operation_metadataContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSet_operation_metadata(s) + } +} + +func (s *Set_operation_metadataContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSet_operation_metadata(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Set_operation_metadata() (localctx ISet_operation_metadataContext) { + localctx = NewSet_operation_metadataContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 728, GoogleSQLParserRULE_set_operation_metadata) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4628) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-72)) & ^0x3f) == 0 && ((int64(1)<<(_la-72))&32801) != 0 { + { + p.SetState(4627) + p.Opt_corresponding_outer_mode() + } + + } + { + p.SetState(4630) + p.Query_set_operation_type() + } + p.SetState(4632) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(4631) + p.Hint() + } + + } + { + p.SetState(4634) + p.All_or_distinct() + } + p.SetState(4636) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserSTRICT_SYMBOL { + { + p.SetState(4635) + p.Opt_strict() + } + + } + p.SetState(4639) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCORRESPONDING_SYMBOL { + { + p.SetState(4638) + p.Opt_column_match_suffix() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_column_match_suffixContext is an interface to support dynamic dispatch. +type IOpt_column_match_suffixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CORRESPONDING_SYMBOL() antlr.TerminalNode + BY_SYMBOL() antlr.TerminalNode + + // IsOpt_column_match_suffixContext differentiates from other interfaces. + IsOpt_column_match_suffixContext() +} + +type Opt_column_match_suffixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_column_match_suffixContext() *Opt_column_match_suffixContext { + var p = new(Opt_column_match_suffixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_column_match_suffix + return p +} + +func InitEmptyOpt_column_match_suffixContext(p *Opt_column_match_suffixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_column_match_suffix +} + +func (*Opt_column_match_suffixContext) IsOpt_column_match_suffixContext() {} + +func NewOpt_column_match_suffixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_column_match_suffixContext { + var p = new(Opt_column_match_suffixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_column_match_suffix + + return p +} + +func (s *Opt_column_match_suffixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_column_match_suffixContext) CORRESPONDING_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCORRESPONDING_SYMBOL, 0) +} + +func (s *Opt_column_match_suffixContext) BY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBY_SYMBOL, 0) +} + +func (s *Opt_column_match_suffixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_column_match_suffixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_column_match_suffixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_column_match_suffix(s) + } +} + +func (s *Opt_column_match_suffixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_column_match_suffix(s) + } +} + +func (s *Opt_column_match_suffixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_column_match_suffix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_column_match_suffix() (localctx IOpt_column_match_suffixContext) { + localctx = NewOpt_column_match_suffixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 730, GoogleSQLParserRULE_opt_column_match_suffix) + p.SetState(4644) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 562, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4641) + p.Match(GoogleSQLParserCORRESPONDING_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4642) + p.Match(GoogleSQLParserCORRESPONDING_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4643) + p.Match(GoogleSQLParserBY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_strictContext is an interface to support dynamic dispatch. +type IOpt_strictContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STRICT_SYMBOL() antlr.TerminalNode + + // IsOpt_strictContext differentiates from other interfaces. + IsOpt_strictContext() +} + +type Opt_strictContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_strictContext() *Opt_strictContext { + var p = new(Opt_strictContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_strict + return p +} + +func InitEmptyOpt_strictContext(p *Opt_strictContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_strict +} + +func (*Opt_strictContext) IsOpt_strictContext() {} + +func NewOpt_strictContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_strictContext { + var p = new(Opt_strictContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_strict + + return p +} + +func (s *Opt_strictContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_strictContext) STRICT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTRICT_SYMBOL, 0) +} + +func (s *Opt_strictContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_strictContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_strictContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_strict(s) + } +} + +func (s *Opt_strictContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_strict(s) + } +} + +func (s *Opt_strictContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_strict(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_strict() (localctx IOpt_strictContext) { + localctx = NewOpt_strictContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 732, GoogleSQLParserRULE_opt_strict) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4646) + p.Match(GoogleSQLParserSTRICT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAll_or_distinctContext is an interface to support dynamic dispatch. +type IAll_or_distinctContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL_SYMBOL() antlr.TerminalNode + DISTINCT_SYMBOL() antlr.TerminalNode + + // IsAll_or_distinctContext differentiates from other interfaces. + IsAll_or_distinctContext() +} + +type All_or_distinctContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAll_or_distinctContext() *All_or_distinctContext { + var p = new(All_or_distinctContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_all_or_distinct + return p +} + +func InitEmptyAll_or_distinctContext(p *All_or_distinctContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_all_or_distinct +} + +func (*All_or_distinctContext) IsAll_or_distinctContext() {} + +func NewAll_or_distinctContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *All_or_distinctContext { + var p = new(All_or_distinctContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_all_or_distinct + + return p +} + +func (s *All_or_distinctContext) GetParser() antlr.Parser { return s.parser } + +func (s *All_or_distinctContext) ALL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserALL_SYMBOL, 0) +} + +func (s *All_or_distinctContext) DISTINCT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDISTINCT_SYMBOL, 0) +} + +func (s *All_or_distinctContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *All_or_distinctContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *All_or_distinctContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterAll_or_distinct(s) + } +} + +func (s *All_or_distinctContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitAll_or_distinct(s) + } +} + +func (s *All_or_distinctContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitAll_or_distinct(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) All_or_distinct() (localctx IAll_or_distinctContext) { + localctx = NewAll_or_distinctContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 734, GoogleSQLParserRULE_all_or_distinct) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4648) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserALL_SYMBOL || _la == GoogleSQLParserDISTINCT_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuery_set_operation_typeContext is an interface to support dynamic dispatch. +type IQuery_set_operation_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNION_SYMBOL() antlr.TerminalNode + EXCEPT_SYMBOL() antlr.TerminalNode + INTERSECT_SYMBOL() antlr.TerminalNode + + // IsQuery_set_operation_typeContext differentiates from other interfaces. + IsQuery_set_operation_typeContext() +} + +type Query_set_operation_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuery_set_operation_typeContext() *Query_set_operation_typeContext { + var p = new(Query_set_operation_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_query_set_operation_type + return p +} + +func InitEmptyQuery_set_operation_typeContext(p *Query_set_operation_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_query_set_operation_type +} + +func (*Query_set_operation_typeContext) IsQuery_set_operation_typeContext() {} + +func NewQuery_set_operation_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_set_operation_typeContext { + var p = new(Query_set_operation_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_query_set_operation_type + + return p +} + +func (s *Query_set_operation_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Query_set_operation_typeContext) UNION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUNION_SYMBOL, 0) +} + +func (s *Query_set_operation_typeContext) EXCEPT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXCEPT_SYMBOL, 0) +} + +func (s *Query_set_operation_typeContext) INTERSECT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINTERSECT_SYMBOL, 0) +} + +func (s *Query_set_operation_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Query_set_operation_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Query_set_operation_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterQuery_set_operation_type(s) + } +} + +func (s *Query_set_operation_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitQuery_set_operation_type(s) + } +} + +func (s *Query_set_operation_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitQuery_set_operation_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Query_set_operation_type() (localctx IQuery_set_operation_typeContext) { + localctx = NewQuery_set_operation_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 736, GoogleSQLParserRULE_query_set_operation_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4650) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-68)) & ^0x3f) == 0 && ((int64(1)<<(_la-68))&4294967553) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_corresponding_outer_modeContext is an interface to support dynamic dispatch. +type IOpt_corresponding_outer_modeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FULL_SYMBOL() antlr.TerminalNode + Opt_outer() IOpt_outerContext + OUTER_SYMBOL() antlr.TerminalNode + LEFT_SYMBOL() antlr.TerminalNode + + // IsOpt_corresponding_outer_modeContext differentiates from other interfaces. + IsOpt_corresponding_outer_modeContext() +} + +type Opt_corresponding_outer_modeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_corresponding_outer_modeContext() *Opt_corresponding_outer_modeContext { + var p = new(Opt_corresponding_outer_modeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_corresponding_outer_mode + return p +} + +func InitEmptyOpt_corresponding_outer_modeContext(p *Opt_corresponding_outer_modeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_corresponding_outer_mode +} + +func (*Opt_corresponding_outer_modeContext) IsOpt_corresponding_outer_modeContext() {} + +func NewOpt_corresponding_outer_modeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_corresponding_outer_modeContext { + var p = new(Opt_corresponding_outer_modeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_corresponding_outer_mode + + return p +} + +func (s *Opt_corresponding_outer_modeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_corresponding_outer_modeContext) FULL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFULL_SYMBOL, 0) +} + +func (s *Opt_corresponding_outer_modeContext) Opt_outer() IOpt_outerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_outerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_outerContext) +} + +func (s *Opt_corresponding_outer_modeContext) OUTER_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOUTER_SYMBOL, 0) +} + +func (s *Opt_corresponding_outer_modeContext) LEFT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLEFT_SYMBOL, 0) +} + +func (s *Opt_corresponding_outer_modeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_corresponding_outer_modeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_corresponding_outer_modeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_corresponding_outer_mode(s) + } +} + +func (s *Opt_corresponding_outer_modeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_corresponding_outer_mode(s) + } +} + +func (s *Opt_corresponding_outer_modeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_corresponding_outer_mode(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_corresponding_outer_mode() (localctx IOpt_corresponding_outer_modeContext) { + localctx = NewOpt_corresponding_outer_modeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 738, GoogleSQLParserRULE_opt_corresponding_outer_mode) + var _la int + + p.SetState(4661) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserFULL_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4652) + p.Match(GoogleSQLParserFULL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4654) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOUTER_SYMBOL { + { + p.SetState(4653) + p.Opt_outer() + } + + } + + case GoogleSQLParserOUTER_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4656) + p.Match(GoogleSQLParserOUTER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserLEFT_SYMBOL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4657) + p.Match(GoogleSQLParserLEFT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4659) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOUTER_SYMBOL { + { + p.SetState(4658) + p.Opt_outer() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_outerContext is an interface to support dynamic dispatch. +type IOpt_outerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OUTER_SYMBOL() antlr.TerminalNode + + // IsOpt_outerContext differentiates from other interfaces. + IsOpt_outerContext() +} + +type Opt_outerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_outerContext() *Opt_outerContext { + var p = new(Opt_outerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_outer + return p +} + +func InitEmptyOpt_outerContext(p *Opt_outerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_outer +} + +func (*Opt_outerContext) IsOpt_outerContext() {} + +func NewOpt_outerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_outerContext { + var p = new(Opt_outerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_outer + + return p +} + +func (s *Opt_outerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_outerContext) OUTER_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOUTER_SYMBOL, 0) +} + +func (s *Opt_outerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_outerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_outerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_outer(s) + } +} + +func (s *Opt_outerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_outer(s) + } +} + +func (s *Opt_outerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_outer(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_outer() (localctx IOpt_outerContext) { + localctx = NewOpt_outerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 740, GoogleSQLParserRULE_opt_outer) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4663) + p.Match(GoogleSQLParserOUTER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWith_clauseContext is an interface to support dynamic dispatch. +type IWith_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH_SYMBOL() antlr.TerminalNode + AllAliased_query() []IAliased_queryContext + Aliased_query(i int) IAliased_queryContext + RECURSIVE_SYMBOL() antlr.TerminalNode + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsWith_clauseContext differentiates from other interfaces. + IsWith_clauseContext() +} + +type With_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWith_clauseContext() *With_clauseContext { + var p = new(With_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_with_clause + return p +} + +func InitEmptyWith_clauseContext(p *With_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_with_clause +} + +func (*With_clauseContext) IsWith_clauseContext() {} + +func NewWith_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_clauseContext { + var p = new(With_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_with_clause + + return p +} + +func (s *With_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *With_clauseContext) WITH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWITH_SYMBOL, 0) +} + +func (s *With_clauseContext) AllAliased_query() []IAliased_queryContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAliased_queryContext); ok { + len++ + } + } + + tst := make([]IAliased_queryContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAliased_queryContext); ok { + tst[i] = t.(IAliased_queryContext) + i++ + } + } + + return tst +} + +func (s *With_clauseContext) Aliased_query(i int) IAliased_queryContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAliased_queryContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAliased_queryContext) +} + +func (s *With_clauseContext) RECURSIVE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRECURSIVE_SYMBOL, 0) +} + +func (s *With_clauseContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *With_clauseContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *With_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *With_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *With_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterWith_clause(s) + } +} + +func (s *With_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitWith_clause(s) + } +} + +func (s *With_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitWith_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) With_clause() (localctx IWith_clauseContext) { + localctx = NewWith_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 742, GoogleSQLParserRULE_with_clause) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4665) + p.Match(GoogleSQLParserWITH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4667) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserRECURSIVE_SYMBOL { + { + p.SetState(4666) + p.Match(GoogleSQLParserRECURSIVE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4669) + p.Aliased_query() + } + p.SetState(4674) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 567, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(4670) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4671) + p.Aliased_query() + } + + } + p.SetState(4676) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 567, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAliased_queryContext is an interface to support dynamic dispatch. +type IAliased_queryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + AS_SYMBOL() antlr.TerminalNode + Parenthesized_query() IParenthesized_queryContext + Opt_aliased_query_modifiers() IOpt_aliased_query_modifiersContext + + // IsAliased_queryContext differentiates from other interfaces. + IsAliased_queryContext() +} + +type Aliased_queryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAliased_queryContext() *Aliased_queryContext { + var p = new(Aliased_queryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_aliased_query + return p +} + +func InitEmptyAliased_queryContext(p *Aliased_queryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_aliased_query +} + +func (*Aliased_queryContext) IsAliased_queryContext() {} + +func NewAliased_queryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aliased_queryContext { + var p = new(Aliased_queryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_aliased_query + + return p +} + +func (s *Aliased_queryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Aliased_queryContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Aliased_queryContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Aliased_queryContext) Parenthesized_query() IParenthesized_queryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesized_queryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParenthesized_queryContext) +} + +func (s *Aliased_queryContext) Opt_aliased_query_modifiers() IOpt_aliased_query_modifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_aliased_query_modifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_aliased_query_modifiersContext) +} + +func (s *Aliased_queryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Aliased_queryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Aliased_queryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterAliased_query(s) + } +} + +func (s *Aliased_queryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitAliased_query(s) + } +} + +func (s *Aliased_queryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitAliased_query(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Aliased_query() (localctx IAliased_queryContext) { + localctx = NewAliased_queryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 744, GoogleSQLParserRULE_aliased_query) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4677) + p.Identifier() + } + { + p.SetState(4678) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4679) + p.Parenthesized_query() + } + p.SetState(4681) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWITH_SYMBOL { + { + p.SetState(4680) + p.Opt_aliased_query_modifiers() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_aliased_query_modifiersContext is an interface to support dynamic dispatch. +type IOpt_aliased_query_modifiersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Recursion_depth_modifier() IRecursion_depth_modifierContext + + // IsOpt_aliased_query_modifiersContext differentiates from other interfaces. + IsOpt_aliased_query_modifiersContext() +} + +type Opt_aliased_query_modifiersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_aliased_query_modifiersContext() *Opt_aliased_query_modifiersContext { + var p = new(Opt_aliased_query_modifiersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_aliased_query_modifiers + return p +} + +func InitEmptyOpt_aliased_query_modifiersContext(p *Opt_aliased_query_modifiersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_aliased_query_modifiers +} + +func (*Opt_aliased_query_modifiersContext) IsOpt_aliased_query_modifiersContext() {} + +func NewOpt_aliased_query_modifiersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_aliased_query_modifiersContext { + var p = new(Opt_aliased_query_modifiersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_aliased_query_modifiers + + return p +} + +func (s *Opt_aliased_query_modifiersContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_aliased_query_modifiersContext) Recursion_depth_modifier() IRecursion_depth_modifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRecursion_depth_modifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRecursion_depth_modifierContext) +} + +func (s *Opt_aliased_query_modifiersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_aliased_query_modifiersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_aliased_query_modifiersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_aliased_query_modifiers(s) + } +} + +func (s *Opt_aliased_query_modifiersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_aliased_query_modifiers(s) + } +} + +func (s *Opt_aliased_query_modifiersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_aliased_query_modifiers(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_aliased_query_modifiers() (localctx IOpt_aliased_query_modifiersContext) { + localctx = NewOpt_aliased_query_modifiersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 746, GoogleSQLParserRULE_opt_aliased_query_modifiers) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4683) + p.Recursion_depth_modifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRecursion_depth_modifierContext is an interface to support dynamic dispatch. +type IRecursion_depth_modifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH_SYMBOL() antlr.TerminalNode + DEPTH_SYMBOL() antlr.TerminalNode + Opt_as_alias_with_required_as() IOpt_as_alias_with_required_asContext + BETWEEN_SYMBOL() antlr.TerminalNode + AllPossibly_unbounded_int_literal_or_parameter() []IPossibly_unbounded_int_literal_or_parameterContext + Possibly_unbounded_int_literal_or_parameter(i int) IPossibly_unbounded_int_literal_or_parameterContext + AND_SYMBOL() antlr.TerminalNode + MAX_SYMBOL() antlr.TerminalNode + + // IsRecursion_depth_modifierContext differentiates from other interfaces. + IsRecursion_depth_modifierContext() +} + +type Recursion_depth_modifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRecursion_depth_modifierContext() *Recursion_depth_modifierContext { + var p = new(Recursion_depth_modifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_recursion_depth_modifier + return p +} + +func InitEmptyRecursion_depth_modifierContext(p *Recursion_depth_modifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_recursion_depth_modifier +} + +func (*Recursion_depth_modifierContext) IsRecursion_depth_modifierContext() {} + +func NewRecursion_depth_modifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Recursion_depth_modifierContext { + var p = new(Recursion_depth_modifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_recursion_depth_modifier + + return p +} + +func (s *Recursion_depth_modifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *Recursion_depth_modifierContext) WITH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWITH_SYMBOL, 0) +} + +func (s *Recursion_depth_modifierContext) DEPTH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDEPTH_SYMBOL, 0) +} + +func (s *Recursion_depth_modifierContext) Opt_as_alias_with_required_as() IOpt_as_alias_with_required_asContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_as_alias_with_required_asContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_as_alias_with_required_asContext) +} + +func (s *Recursion_depth_modifierContext) BETWEEN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBETWEEN_SYMBOL, 0) +} + +func (s *Recursion_depth_modifierContext) AllPossibly_unbounded_int_literal_or_parameter() []IPossibly_unbounded_int_literal_or_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPossibly_unbounded_int_literal_or_parameterContext); ok { + len++ + } + } + + tst := make([]IPossibly_unbounded_int_literal_or_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPossibly_unbounded_int_literal_or_parameterContext); ok { + tst[i] = t.(IPossibly_unbounded_int_literal_or_parameterContext) + i++ + } + } + + return tst +} + +func (s *Recursion_depth_modifierContext) Possibly_unbounded_int_literal_or_parameter(i int) IPossibly_unbounded_int_literal_or_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPossibly_unbounded_int_literal_or_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPossibly_unbounded_int_literal_or_parameterContext) +} + +func (s *Recursion_depth_modifierContext) AND_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAND_SYMBOL, 0) +} + +func (s *Recursion_depth_modifierContext) MAX_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMAX_SYMBOL, 0) +} + +func (s *Recursion_depth_modifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Recursion_depth_modifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Recursion_depth_modifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterRecursion_depth_modifier(s) + } +} + +func (s *Recursion_depth_modifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitRecursion_depth_modifier(s) + } +} + +func (s *Recursion_depth_modifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitRecursion_depth_modifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Recursion_depth_modifier() (localctx IRecursion_depth_modifierContext) { + localctx = NewRecursion_depth_modifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 748, GoogleSQLParserRULE_recursion_depth_modifier) + var _la int + + p.SetState(4707) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 572, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4685) + p.Match(GoogleSQLParserWITH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4686) + p.Match(GoogleSQLParserDEPTH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4688) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(4687) + p.Opt_as_alias_with_required_as() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4690) + p.Match(GoogleSQLParserWITH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4691) + p.Match(GoogleSQLParserDEPTH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4693) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(4692) + p.Opt_as_alias_with_required_as() + } + + } + { + p.SetState(4695) + p.Match(GoogleSQLParserBETWEEN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4696) + p.Possibly_unbounded_int_literal_or_parameter() + } + { + p.SetState(4697) + p.Match(GoogleSQLParserAND_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4698) + p.Possibly_unbounded_int_literal_or_parameter() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4700) + p.Match(GoogleSQLParserWITH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4701) + p.Match(GoogleSQLParserDEPTH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4703) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(4702) + p.Opt_as_alias_with_required_as() + } + + } + { + p.SetState(4705) + p.Match(GoogleSQLParserMAX_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4706) + p.Possibly_unbounded_int_literal_or_parameter() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPossibly_unbounded_int_literal_or_parameterContext is an interface to support dynamic dispatch. +type IPossibly_unbounded_int_literal_or_parameterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Int_literal_or_parameter() IInt_literal_or_parameterContext + UNBOUNDED_SYMBOL() antlr.TerminalNode + + // IsPossibly_unbounded_int_literal_or_parameterContext differentiates from other interfaces. + IsPossibly_unbounded_int_literal_or_parameterContext() +} + +type Possibly_unbounded_int_literal_or_parameterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPossibly_unbounded_int_literal_or_parameterContext() *Possibly_unbounded_int_literal_or_parameterContext { + var p = new(Possibly_unbounded_int_literal_or_parameterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_possibly_unbounded_int_literal_or_parameter + return p +} + +func InitEmptyPossibly_unbounded_int_literal_or_parameterContext(p *Possibly_unbounded_int_literal_or_parameterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_possibly_unbounded_int_literal_or_parameter +} + +func (*Possibly_unbounded_int_literal_or_parameterContext) IsPossibly_unbounded_int_literal_or_parameterContext() { +} + +func NewPossibly_unbounded_int_literal_or_parameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Possibly_unbounded_int_literal_or_parameterContext { + var p = new(Possibly_unbounded_int_literal_or_parameterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_possibly_unbounded_int_literal_or_parameter + + return p +} + +func (s *Possibly_unbounded_int_literal_or_parameterContext) GetParser() antlr.Parser { + return s.parser +} + +func (s *Possibly_unbounded_int_literal_or_parameterContext) Int_literal_or_parameter() IInt_literal_or_parameterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInt_literal_or_parameterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInt_literal_or_parameterContext) +} + +func (s *Possibly_unbounded_int_literal_or_parameterContext) UNBOUNDED_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUNBOUNDED_SYMBOL, 0) +} + +func (s *Possibly_unbounded_int_literal_or_parameterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Possibly_unbounded_int_literal_or_parameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Possibly_unbounded_int_literal_or_parameterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPossibly_unbounded_int_literal_or_parameter(s) + } +} + +func (s *Possibly_unbounded_int_literal_or_parameterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPossibly_unbounded_int_literal_or_parameter(s) + } +} + +func (s *Possibly_unbounded_int_literal_or_parameterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPossibly_unbounded_int_literal_or_parameter(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Possibly_unbounded_int_literal_or_parameter() (localctx IPossibly_unbounded_int_literal_or_parameterContext) { + localctx = NewPossibly_unbounded_int_literal_or_parameterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 750, GoogleSQLParserRULE_possibly_unbounded_int_literal_or_parameter) + p.SetState(4711) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserQUESTION_SYMBOL, GoogleSQLParserAT_SYMBOL, GoogleSQLParserATAT_SYMBOL, GoogleSQLParserINTEGER_LITERAL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4709) + p.Int_literal_or_parameter() + } + + case GoogleSQLParserUNBOUNDED_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4710) + p.Match(GoogleSQLParserUNBOUNDED_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInt_literal_or_parameterContext is an interface to support dynamic dispatch. +type IInt_literal_or_parameterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Integer_literal() IInteger_literalContext + Parameter_expression() IParameter_expressionContext + System_variable_expression() ISystem_variable_expressionContext + + // IsInt_literal_or_parameterContext differentiates from other interfaces. + IsInt_literal_or_parameterContext() +} + +type Int_literal_or_parameterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInt_literal_or_parameterContext() *Int_literal_or_parameterContext { + var p = new(Int_literal_or_parameterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_int_literal_or_parameter + return p +} + +func InitEmptyInt_literal_or_parameterContext(p *Int_literal_or_parameterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_int_literal_or_parameter +} + +func (*Int_literal_or_parameterContext) IsInt_literal_or_parameterContext() {} + +func NewInt_literal_or_parameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Int_literal_or_parameterContext { + var p = new(Int_literal_or_parameterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_int_literal_or_parameter + + return p +} + +func (s *Int_literal_or_parameterContext) GetParser() antlr.Parser { return s.parser } + +func (s *Int_literal_or_parameterContext) Integer_literal() IInteger_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInteger_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInteger_literalContext) +} + +func (s *Int_literal_or_parameterContext) Parameter_expression() IParameter_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameter_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameter_expressionContext) +} + +func (s *Int_literal_or_parameterContext) System_variable_expression() ISystem_variable_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISystem_variable_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISystem_variable_expressionContext) +} + +func (s *Int_literal_or_parameterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Int_literal_or_parameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Int_literal_or_parameterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterInt_literal_or_parameter(s) + } +} + +func (s *Int_literal_or_parameterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitInt_literal_or_parameter(s) + } +} + +func (s *Int_literal_or_parameterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitInt_literal_or_parameter(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Int_literal_or_parameter() (localctx IInt_literal_or_parameterContext) { + localctx = NewInt_literal_or_parameterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 752, GoogleSQLParserRULE_int_literal_or_parameter) + p.SetState(4716) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserINTEGER_LITERAL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4713) + p.Integer_literal() + } + + case GoogleSQLParserQUESTION_SYMBOL, GoogleSQLParserAT_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4714) + p.Parameter_expression() + } + + case GoogleSQLParserATAT_SYMBOL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4715) + p.System_variable_expression() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOrder_by_clauseContext is an interface to support dynamic dispatch. +type IOrder_by_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Order_by_clause_prefix() IOrder_by_clause_prefixContext + + // IsOrder_by_clauseContext differentiates from other interfaces. + IsOrder_by_clauseContext() +} + +type Order_by_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOrder_by_clauseContext() *Order_by_clauseContext { + var p = new(Order_by_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_order_by_clause + return p +} + +func InitEmptyOrder_by_clauseContext(p *Order_by_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_order_by_clause +} + +func (*Order_by_clauseContext) IsOrder_by_clauseContext() {} + +func NewOrder_by_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Order_by_clauseContext { + var p = new(Order_by_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_order_by_clause + + return p +} + +func (s *Order_by_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Order_by_clauseContext) Order_by_clause_prefix() IOrder_by_clause_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_clause_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_clause_prefixContext) +} + +func (s *Order_by_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Order_by_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Order_by_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOrder_by_clause(s) + } +} + +func (s *Order_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOrder_by_clause(s) + } +} + +func (s *Order_by_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOrder_by_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Order_by_clause() (localctx IOrder_by_clauseContext) { + localctx = NewOrder_by_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 754, GoogleSQLParserRULE_order_by_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4718) + p.Order_by_clause_prefix() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOrder_by_clause_prefixContext is an interface to support dynamic dispatch. +type IOrder_by_clause_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ORDER_SYMBOL() antlr.TerminalNode + BY_SYMBOL() antlr.TerminalNode + AllOrdering_expression() []IOrdering_expressionContext + Ordering_expression(i int) IOrdering_expressionContext + Hint() IHintContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsOrder_by_clause_prefixContext differentiates from other interfaces. + IsOrder_by_clause_prefixContext() +} + +type Order_by_clause_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOrder_by_clause_prefixContext() *Order_by_clause_prefixContext { + var p = new(Order_by_clause_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_order_by_clause_prefix + return p +} + +func InitEmptyOrder_by_clause_prefixContext(p *Order_by_clause_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_order_by_clause_prefix +} + +func (*Order_by_clause_prefixContext) IsOrder_by_clause_prefixContext() {} + +func NewOrder_by_clause_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Order_by_clause_prefixContext { + var p = new(Order_by_clause_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_order_by_clause_prefix + + return p +} + +func (s *Order_by_clause_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Order_by_clause_prefixContext) ORDER_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserORDER_SYMBOL, 0) +} + +func (s *Order_by_clause_prefixContext) BY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBY_SYMBOL, 0) +} + +func (s *Order_by_clause_prefixContext) AllOrdering_expression() []IOrdering_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOrdering_expressionContext); ok { + len++ + } + } + + tst := make([]IOrdering_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOrdering_expressionContext); ok { + tst[i] = t.(IOrdering_expressionContext) + i++ + } + } + + return tst +} + +func (s *Order_by_clause_prefixContext) Ordering_expression(i int) IOrdering_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrdering_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOrdering_expressionContext) +} + +func (s *Order_by_clause_prefixContext) Hint() IHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Order_by_clause_prefixContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Order_by_clause_prefixContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Order_by_clause_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Order_by_clause_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Order_by_clause_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOrder_by_clause_prefix(s) + } +} + +func (s *Order_by_clause_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOrder_by_clause_prefix(s) + } +} + +func (s *Order_by_clause_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOrder_by_clause_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Order_by_clause_prefix() (localctx IOrder_by_clause_prefixContext) { + localctx = NewOrder_by_clause_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 756, GoogleSQLParserRULE_order_by_clause_prefix) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4720) + p.Match(GoogleSQLParserORDER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4722) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(4721) + p.Hint() + } + + } + { + p.SetState(4724) + p.Match(GoogleSQLParserBY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4725) + p.Ordering_expression() + } + p.SetState(4730) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(4726) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4727) + p.Ordering_expression() + } + + p.SetState(4732) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOrdering_expressionContext is an interface to support dynamic dispatch. +type IOrdering_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + Collate_clause() ICollate_clauseContext + Asc_or_desc() IAsc_or_descContext + Null_order() INull_orderContext + + // IsOrdering_expressionContext differentiates from other interfaces. + IsOrdering_expressionContext() +} + +type Ordering_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOrdering_expressionContext() *Ordering_expressionContext { + var p = new(Ordering_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_ordering_expression + return p +} + +func InitEmptyOrdering_expressionContext(p *Ordering_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_ordering_expression +} + +func (*Ordering_expressionContext) IsOrdering_expressionContext() {} + +func NewOrdering_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ordering_expressionContext { + var p = new(Ordering_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_ordering_expression + + return p +} + +func (s *Ordering_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ordering_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Ordering_expressionContext) Collate_clause() ICollate_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollate_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollate_clauseContext) +} + +func (s *Ordering_expressionContext) Asc_or_desc() IAsc_or_descContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAsc_or_descContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAsc_or_descContext) +} + +func (s *Ordering_expressionContext) Null_order() INull_orderContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INull_orderContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INull_orderContext) +} + +func (s *Ordering_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ordering_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ordering_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOrdering_expression(s) + } +} + +func (s *Ordering_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOrdering_expression(s) + } +} + +func (s *Ordering_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOrdering_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Ordering_expression() (localctx IOrdering_expressionContext) { + localctx = NewOrdering_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 758, GoogleSQLParserRULE_ordering_expression) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4733) + p.expression(0) + } + p.SetState(4735) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCOLLATE_SYMBOL { + { + p.SetState(4734) + p.Collate_clause() + } + + } + p.SetState(4738) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserASC_SYMBOL || _la == GoogleSQLParserDESC_SYMBOL { + { + p.SetState(4737) + p.Asc_or_desc() + } + + } + p.SetState(4741) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserNULLS_SYMBOL { + { + p.SetState(4740) + p.Null_order() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelectContext is an interface to support dynamic dispatch. +type ISelectContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Select_clause() ISelect_clauseContext + From_clause() IFrom_clauseContext + Opt_clauses_following_from() IOpt_clauses_following_fromContext + + // IsSelectContext differentiates from other interfaces. + IsSelectContext() +} + +type SelectContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelectContext() *SelectContext { + var p = new(SelectContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_select + return p +} + +func InitEmptySelectContext(p *SelectContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_select +} + +func (*SelectContext) IsSelectContext() {} + +func NewSelectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectContext { + var p = new(SelectContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_select + + return p +} + +func (s *SelectContext) GetParser() antlr.Parser { return s.parser } + +func (s *SelectContext) Select_clause() ISelect_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_clauseContext) +} + +func (s *SelectContext) From_clause() IFrom_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrom_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrom_clauseContext) +} + +func (s *SelectContext) Opt_clauses_following_from() IOpt_clauses_following_fromContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_clauses_following_fromContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_clauses_following_fromContext) +} + +func (s *SelectContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SelectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SelectContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSelect(s) + } +} + +func (s *SelectContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSelect(s) + } +} + +func (s *SelectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSelect(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Select_() (localctx ISelectContext) { + localctx = NewSelectContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 760, GoogleSQLParserRULE_select) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4743) + p.Select_clause() + } + p.SetState(4745) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 580, p.GetParserRuleContext()) == 1 { + { + p.SetState(4744) + p.From_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4748) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 581, p.GetParserRuleContext()) == 1 { + { + p.SetState(4747) + p.Opt_clauses_following_from() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_clauses_following_fromContext is an interface to support dynamic dispatch. +type IOpt_clauses_following_fromContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Where_clause() IWhere_clauseContext + Group_by_clause() IGroup_by_clauseContext + Having_clause() IHaving_clauseContext + Qualify_clause_nonreserved() IQualify_clause_nonreservedContext + Window_clause() IWindow_clauseContext + Opt_clauses_following_where() IOpt_clauses_following_whereContext + + // IsOpt_clauses_following_fromContext differentiates from other interfaces. + IsOpt_clauses_following_fromContext() +} + +type Opt_clauses_following_fromContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_clauses_following_fromContext() *Opt_clauses_following_fromContext { + var p = new(Opt_clauses_following_fromContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_clauses_following_from + return p +} + +func InitEmptyOpt_clauses_following_fromContext(p *Opt_clauses_following_fromContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_clauses_following_from +} + +func (*Opt_clauses_following_fromContext) IsOpt_clauses_following_fromContext() {} + +func NewOpt_clauses_following_fromContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_clauses_following_fromContext { + var p = new(Opt_clauses_following_fromContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_clauses_following_from + + return p +} + +func (s *Opt_clauses_following_fromContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_clauses_following_fromContext) Where_clause() IWhere_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_clauseContext) +} + +func (s *Opt_clauses_following_fromContext) Group_by_clause() IGroup_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGroup_by_clauseContext) +} + +func (s *Opt_clauses_following_fromContext) Having_clause() IHaving_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHaving_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHaving_clauseContext) +} + +func (s *Opt_clauses_following_fromContext) Qualify_clause_nonreserved() IQualify_clause_nonreservedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualify_clause_nonreservedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualify_clause_nonreservedContext) +} + +func (s *Opt_clauses_following_fromContext) Window_clause() IWindow_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindow_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindow_clauseContext) +} + +func (s *Opt_clauses_following_fromContext) Opt_clauses_following_where() IOpt_clauses_following_whereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_clauses_following_whereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_clauses_following_whereContext) +} + +func (s *Opt_clauses_following_fromContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_clauses_following_fromContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_clauses_following_fromContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_clauses_following_from(s) + } +} + +func (s *Opt_clauses_following_fromContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_clauses_following_from(s) + } +} + +func (s *Opt_clauses_following_fromContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_clauses_following_from(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_clauses_following_from() (localctx IOpt_clauses_following_fromContext) { + localctx = NewOpt_clauses_following_fromContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 762, GoogleSQLParserRULE_opt_clauses_following_from) + p.SetState(4764) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserWHERE_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4750) + p.Where_clause() + } + p.SetState(4752) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 582, p.GetParserRuleContext()) == 1 { + { + p.SetState(4751) + p.Group_by_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4755) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 583, p.GetParserRuleContext()) == 1 { + { + p.SetState(4754) + p.Having_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4758) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 584, p.GetParserRuleContext()) == 1 { + { + p.SetState(4757) + p.Qualify_clause_nonreserved() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4761) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 585, p.GetParserRuleContext()) == 1 { + { + p.SetState(4760) + p.Window_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case GoogleSQLParserHAVING_SYMBOL, GoogleSQLParserGROUP_SYMBOL, GoogleSQLParserQUALIFY_SYMBOL, GoogleSQLParserWINDOW_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4763) + p.Opt_clauses_following_where() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_clauses_following_whereContext is an interface to support dynamic dispatch. +type IOpt_clauses_following_whereContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Group_by_clause() IGroup_by_clauseContext + Having_clause() IHaving_clauseContext + Qualify_clause_nonreserved() IQualify_clause_nonreservedContext + Window_clause() IWindow_clauseContext + Opt_clauses_following_group_by() IOpt_clauses_following_group_byContext + + // IsOpt_clauses_following_whereContext differentiates from other interfaces. + IsOpt_clauses_following_whereContext() +} + +type Opt_clauses_following_whereContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_clauses_following_whereContext() *Opt_clauses_following_whereContext { + var p = new(Opt_clauses_following_whereContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_clauses_following_where + return p +} + +func InitEmptyOpt_clauses_following_whereContext(p *Opt_clauses_following_whereContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_clauses_following_where +} + +func (*Opt_clauses_following_whereContext) IsOpt_clauses_following_whereContext() {} + +func NewOpt_clauses_following_whereContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_clauses_following_whereContext { + var p = new(Opt_clauses_following_whereContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_clauses_following_where + + return p +} + +func (s *Opt_clauses_following_whereContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_clauses_following_whereContext) Group_by_clause() IGroup_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGroup_by_clauseContext) +} + +func (s *Opt_clauses_following_whereContext) Having_clause() IHaving_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHaving_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHaving_clauseContext) +} + +func (s *Opt_clauses_following_whereContext) Qualify_clause_nonreserved() IQualify_clause_nonreservedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualify_clause_nonreservedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualify_clause_nonreservedContext) +} + +func (s *Opt_clauses_following_whereContext) Window_clause() IWindow_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindow_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindow_clauseContext) +} + +func (s *Opt_clauses_following_whereContext) Opt_clauses_following_group_by() IOpt_clauses_following_group_byContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_clauses_following_group_byContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_clauses_following_group_byContext) +} + +func (s *Opt_clauses_following_whereContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_clauses_following_whereContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_clauses_following_whereContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_clauses_following_where(s) + } +} + +func (s *Opt_clauses_following_whereContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_clauses_following_where(s) + } +} + +func (s *Opt_clauses_following_whereContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_clauses_following_where(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_clauses_following_where() (localctx IOpt_clauses_following_whereContext) { + localctx = NewOpt_clauses_following_whereContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 764, GoogleSQLParserRULE_opt_clauses_following_where) + p.SetState(4777) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserGROUP_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4766) + p.Group_by_clause() + } + p.SetState(4768) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 587, p.GetParserRuleContext()) == 1 { + { + p.SetState(4767) + p.Having_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4771) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 588, p.GetParserRuleContext()) == 1 { + { + p.SetState(4770) + p.Qualify_clause_nonreserved() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4774) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 589, p.GetParserRuleContext()) == 1 { + { + p.SetState(4773) + p.Window_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case GoogleSQLParserHAVING_SYMBOL, GoogleSQLParserQUALIFY_SYMBOL, GoogleSQLParserWINDOW_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4776) + p.Opt_clauses_following_group_by() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_clauses_following_group_byContext is an interface to support dynamic dispatch. +type IOpt_clauses_following_group_byContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Having_clause() IHaving_clauseContext + Qualify_clause_nonreserved() IQualify_clause_nonreservedContext + Window_clause() IWindow_clauseContext + + // IsOpt_clauses_following_group_byContext differentiates from other interfaces. + IsOpt_clauses_following_group_byContext() +} + +type Opt_clauses_following_group_byContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_clauses_following_group_byContext() *Opt_clauses_following_group_byContext { + var p = new(Opt_clauses_following_group_byContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_clauses_following_group_by + return p +} + +func InitEmptyOpt_clauses_following_group_byContext(p *Opt_clauses_following_group_byContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_clauses_following_group_by +} + +func (*Opt_clauses_following_group_byContext) IsOpt_clauses_following_group_byContext() {} + +func NewOpt_clauses_following_group_byContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_clauses_following_group_byContext { + var p = new(Opt_clauses_following_group_byContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_clauses_following_group_by + + return p +} + +func (s *Opt_clauses_following_group_byContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_clauses_following_group_byContext) Having_clause() IHaving_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHaving_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHaving_clauseContext) +} + +func (s *Opt_clauses_following_group_byContext) Qualify_clause_nonreserved() IQualify_clause_nonreservedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualify_clause_nonreservedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualify_clause_nonreservedContext) +} + +func (s *Opt_clauses_following_group_byContext) Window_clause() IWindow_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindow_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindow_clauseContext) +} + +func (s *Opt_clauses_following_group_byContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_clauses_following_group_byContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_clauses_following_group_byContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_clauses_following_group_by(s) + } +} + +func (s *Opt_clauses_following_group_byContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_clauses_following_group_by(s) + } +} + +func (s *Opt_clauses_following_group_byContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_clauses_following_group_by(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_clauses_following_group_by() (localctx IOpt_clauses_following_group_byContext) { + localctx = NewOpt_clauses_following_group_byContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 766, GoogleSQLParserRULE_opt_clauses_following_group_by) + p.SetState(4791) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserHAVING_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4779) + p.Having_clause() + } + p.SetState(4781) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 591, p.GetParserRuleContext()) == 1 { + { + p.SetState(4780) + p.Qualify_clause_nonreserved() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4784) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 592, p.GetParserRuleContext()) == 1 { + { + p.SetState(4783) + p.Window_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case GoogleSQLParserQUALIFY_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4786) + p.Qualify_clause_nonreserved() + } + p.SetState(4788) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 593, p.GetParserRuleContext()) == 1 { + { + p.SetState(4787) + p.Window_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case GoogleSQLParserWINDOW_SYMBOL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4790) + p.Window_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWindow_clauseContext is an interface to support dynamic dispatch. +type IWindow_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Window_clause_prefix() IWindow_clause_prefixContext + + // IsWindow_clauseContext differentiates from other interfaces. + IsWindow_clauseContext() +} + +type Window_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindow_clauseContext() *Window_clauseContext { + var p = new(Window_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_window_clause + return p +} + +func InitEmptyWindow_clauseContext(p *Window_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_window_clause +} + +func (*Window_clauseContext) IsWindow_clauseContext() {} + +func NewWindow_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_clauseContext { + var p = new(Window_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_window_clause + + return p +} + +func (s *Window_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Window_clauseContext) Window_clause_prefix() IWindow_clause_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindow_clause_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindow_clause_prefixContext) +} + +func (s *Window_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Window_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Window_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterWindow_clause(s) + } +} + +func (s *Window_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitWindow_clause(s) + } +} + +func (s *Window_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitWindow_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Window_clause() (localctx IWindow_clauseContext) { + localctx = NewWindow_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 768, GoogleSQLParserRULE_window_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4793) + p.Window_clause_prefix() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWindow_clause_prefixContext is an interface to support dynamic dispatch. +type IWindow_clause_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WINDOW_SYMBOL() antlr.TerminalNode + AllWindow_definition() []IWindow_definitionContext + Window_definition(i int) IWindow_definitionContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsWindow_clause_prefixContext differentiates from other interfaces. + IsWindow_clause_prefixContext() +} + +type Window_clause_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindow_clause_prefixContext() *Window_clause_prefixContext { + var p = new(Window_clause_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_window_clause_prefix + return p +} + +func InitEmptyWindow_clause_prefixContext(p *Window_clause_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_window_clause_prefix +} + +func (*Window_clause_prefixContext) IsWindow_clause_prefixContext() {} + +func NewWindow_clause_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_clause_prefixContext { + var p = new(Window_clause_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_window_clause_prefix + + return p +} + +func (s *Window_clause_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Window_clause_prefixContext) WINDOW_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWINDOW_SYMBOL, 0) +} + +func (s *Window_clause_prefixContext) AllWindow_definition() []IWindow_definitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWindow_definitionContext); ok { + len++ + } + } + + tst := make([]IWindow_definitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWindow_definitionContext); ok { + tst[i] = t.(IWindow_definitionContext) + i++ + } + } + + return tst +} + +func (s *Window_clause_prefixContext) Window_definition(i int) IWindow_definitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindow_definitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWindow_definitionContext) +} + +func (s *Window_clause_prefixContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Window_clause_prefixContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Window_clause_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Window_clause_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Window_clause_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterWindow_clause_prefix(s) + } +} + +func (s *Window_clause_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitWindow_clause_prefix(s) + } +} + +func (s *Window_clause_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitWindow_clause_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Window_clause_prefix() (localctx IWindow_clause_prefixContext) { + localctx = NewWindow_clause_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 770, GoogleSQLParserRULE_window_clause_prefix) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4795) + p.Match(GoogleSQLParserWINDOW_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4796) + p.Window_definition() + } + p.SetState(4801) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 595, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(4797) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4798) + p.Window_definition() + } + + } + p.SetState(4803) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 595, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWindow_definitionContext is an interface to support dynamic dispatch. +type IWindow_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + AS_SYMBOL() antlr.TerminalNode + Window_specification() IWindow_specificationContext + + // IsWindow_definitionContext differentiates from other interfaces. + IsWindow_definitionContext() +} + +type Window_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindow_definitionContext() *Window_definitionContext { + var p = new(Window_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_window_definition + return p +} + +func InitEmptyWindow_definitionContext(p *Window_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_window_definition +} + +func (*Window_definitionContext) IsWindow_definitionContext() {} + +func NewWindow_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_definitionContext { + var p = new(Window_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_window_definition + + return p +} + +func (s *Window_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Window_definitionContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Window_definitionContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Window_definitionContext) Window_specification() IWindow_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindow_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindow_specificationContext) +} + +func (s *Window_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Window_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Window_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterWindow_definition(s) + } +} + +func (s *Window_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitWindow_definition(s) + } +} + +func (s *Window_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitWindow_definition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Window_definition() (localctx IWindow_definitionContext) { + localctx = NewWindow_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 772, GoogleSQLParserRULE_window_definition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4804) + p.Identifier() + } + { + p.SetState(4805) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4806) + p.Window_specification() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWhere_clauseContext is an interface to support dynamic dispatch. +type IWhere_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHERE_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + + // IsWhere_clauseContext differentiates from other interfaces. + IsWhere_clauseContext() +} + +type Where_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWhere_clauseContext() *Where_clauseContext { + var p = new(Where_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_where_clause + return p +} + +func InitEmptyWhere_clauseContext(p *Where_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_where_clause +} + +func (*Where_clauseContext) IsWhere_clauseContext() {} + +func NewWhere_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Where_clauseContext { + var p = new(Where_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_where_clause + + return p +} + +func (s *Where_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Where_clauseContext) WHERE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWHERE_SYMBOL, 0) +} + +func (s *Where_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Where_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Where_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Where_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterWhere_clause(s) + } +} + +func (s *Where_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitWhere_clause(s) + } +} + +func (s *Where_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitWhere_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Where_clause() (localctx IWhere_clauseContext) { + localctx = NewWhere_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 774, GoogleSQLParserRULE_where_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4808) + p.Match(GoogleSQLParserWHERE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4809) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHaving_clauseContext is an interface to support dynamic dispatch. +type IHaving_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HAVING_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + + // IsHaving_clauseContext differentiates from other interfaces. + IsHaving_clauseContext() +} + +type Having_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHaving_clauseContext() *Having_clauseContext { + var p = new(Having_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_having_clause + return p +} + +func InitEmptyHaving_clauseContext(p *Having_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_having_clause +} + +func (*Having_clauseContext) IsHaving_clauseContext() {} + +func NewHaving_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Having_clauseContext { + var p = new(Having_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_having_clause + + return p +} + +func (s *Having_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Having_clauseContext) HAVING_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserHAVING_SYMBOL, 0) +} + +func (s *Having_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Having_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Having_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Having_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterHaving_clause(s) + } +} + +func (s *Having_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitHaving_clause(s) + } +} + +func (s *Having_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitHaving_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Having_clause() (localctx IHaving_clauseContext) { + localctx = NewHaving_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 776, GoogleSQLParserRULE_having_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4811) + p.Match(GoogleSQLParserHAVING_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4812) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGroup_by_clauseContext is an interface to support dynamic dispatch. +type IGroup_by_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Group_by_all() IGroup_by_allContext + Group_by_clause_prefix() IGroup_by_clause_prefixContext + + // IsGroup_by_clauseContext differentiates from other interfaces. + IsGroup_by_clauseContext() +} + +type Group_by_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGroup_by_clauseContext() *Group_by_clauseContext { + var p = new(Group_by_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_group_by_clause + return p +} + +func InitEmptyGroup_by_clauseContext(p *Group_by_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_group_by_clause +} + +func (*Group_by_clauseContext) IsGroup_by_clauseContext() {} + +func NewGroup_by_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Group_by_clauseContext { + var p = new(Group_by_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_group_by_clause + + return p +} + +func (s *Group_by_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Group_by_clauseContext) Group_by_all() IGroup_by_allContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_by_allContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGroup_by_allContext) +} + +func (s *Group_by_clauseContext) Group_by_clause_prefix() IGroup_by_clause_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_by_clause_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGroup_by_clause_prefixContext) +} + +func (s *Group_by_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Group_by_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Group_by_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGroup_by_clause(s) + } +} + +func (s *Group_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGroup_by_clause(s) + } +} + +func (s *Group_by_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGroup_by_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Group_by_clause() (localctx IGroup_by_clauseContext) { + localctx = NewGroup_by_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 778, GoogleSQLParserRULE_group_by_clause) + p.SetState(4816) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 596, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4814) + p.Group_by_all() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4815) + p.Group_by_clause_prefix() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGroup_by_allContext is an interface to support dynamic dispatch. +type IGroup_by_allContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Group_by_preamble() IGroup_by_preambleContext + ALL_SYMBOL() antlr.TerminalNode + + // IsGroup_by_allContext differentiates from other interfaces. + IsGroup_by_allContext() +} + +type Group_by_allContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGroup_by_allContext() *Group_by_allContext { + var p = new(Group_by_allContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_group_by_all + return p +} + +func InitEmptyGroup_by_allContext(p *Group_by_allContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_group_by_all +} + +func (*Group_by_allContext) IsGroup_by_allContext() {} + +func NewGroup_by_allContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Group_by_allContext { + var p = new(Group_by_allContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_group_by_all + + return p +} + +func (s *Group_by_allContext) GetParser() antlr.Parser { return s.parser } + +func (s *Group_by_allContext) Group_by_preamble() IGroup_by_preambleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_by_preambleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGroup_by_preambleContext) +} + +func (s *Group_by_allContext) ALL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserALL_SYMBOL, 0) +} + +func (s *Group_by_allContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Group_by_allContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Group_by_allContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGroup_by_all(s) + } +} + +func (s *Group_by_allContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGroup_by_all(s) + } +} + +func (s *Group_by_allContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGroup_by_all(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Group_by_all() (localctx IGroup_by_allContext) { + localctx = NewGroup_by_allContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 780, GoogleSQLParserRULE_group_by_all) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4818) + p.Group_by_preamble() + } + { + p.SetState(4819) + p.Match(GoogleSQLParserALL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_clauseContext is an interface to support dynamic dispatch. +type ISelect_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SELECT_SYMBOL() antlr.TerminalNode + Select_list() ISelect_listContext + Hint() IHintContext + Opt_select_with() IOpt_select_withContext + All_or_distinct() IAll_or_distinctContext + Opt_select_as_clause() IOpt_select_as_clauseContext + FROM_SYMBOL() antlr.TerminalNode + + // IsSelect_clauseContext differentiates from other interfaces. + IsSelect_clauseContext() +} + +type Select_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_clauseContext() *Select_clauseContext { + var p = new(Select_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_select_clause + return p +} + +func InitEmptySelect_clauseContext(p *Select_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_select_clause +} + +func (*Select_clauseContext) IsSelect_clauseContext() {} + +func NewSelect_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_clauseContext { + var p = new(Select_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_select_clause + + return p +} + +func (s *Select_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_clauseContext) SELECT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSELECT_SYMBOL, 0) +} + +func (s *Select_clauseContext) Select_list() ISelect_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_listContext) +} + +func (s *Select_clauseContext) Hint() IHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Select_clauseContext) Opt_select_with() IOpt_select_withContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_select_withContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_select_withContext) +} + +func (s *Select_clauseContext) All_or_distinct() IAll_or_distinctContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_or_distinctContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_or_distinctContext) +} + +func (s *Select_clauseContext) Opt_select_as_clause() IOpt_select_as_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_select_as_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_select_as_clauseContext) +} + +func (s *Select_clauseContext) FROM_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFROM_SYMBOL, 0) +} + +func (s *Select_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSelect_clause(s) + } +} + +func (s *Select_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSelect_clause(s) + } +} + +func (s *Select_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSelect_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Select_clause() (localctx ISelect_clauseContext) { + localctx = NewSelect_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 782, GoogleSQLParserRULE_select_clause) + var _la int + + p.SetState(4850) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 605, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4821) + p.Match(GoogleSQLParserSELECT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4823) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 597, p.GetParserRuleContext()) == 1 { + { + p.SetState(4822) + p.Hint() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4826) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 598, p.GetParserRuleContext()) == 1 { + { + p.SetState(4825) + p.Opt_select_with() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4829) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserALL_SYMBOL || _la == GoogleSQLParserDISTINCT_SYMBOL { + { + p.SetState(4828) + p.All_or_distinct() + } + + } + p.SetState(4832) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(4831) + p.Opt_select_as_clause() + } + + } + { + p.SetState(4834) + p.Select_list() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4835) + p.Match(GoogleSQLParserSELECT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4837) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(4836) + p.Hint() + } + + } + p.SetState(4840) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWITH_SYMBOL { + { + p.SetState(4839) + p.Opt_select_with() + } + + } + p.SetState(4843) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserALL_SYMBOL || _la == GoogleSQLParserDISTINCT_SYMBOL { + { + p.SetState(4842) + p.All_or_distinct() + } + + } + p.SetState(4846) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(4845) + p.Opt_select_as_clause() + } + + } + { + p.SetState(4848) + p.Match(GoogleSQLParserFROM_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.NotifyErrorListeners("Syntax error: SELECT list must not be empty", nil, nil) + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_select_as_clauseContext is an interface to support dynamic dispatch. +type IOpt_select_as_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AS_SYMBOL() antlr.TerminalNode + STRUCT_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + + // IsOpt_select_as_clauseContext differentiates from other interfaces. + IsOpt_select_as_clauseContext() +} + +type Opt_select_as_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_select_as_clauseContext() *Opt_select_as_clauseContext { + var p = new(Opt_select_as_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_select_as_clause + return p +} + +func InitEmptyOpt_select_as_clauseContext(p *Opt_select_as_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_select_as_clause +} + +func (*Opt_select_as_clauseContext) IsOpt_select_as_clauseContext() {} + +func NewOpt_select_as_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_select_as_clauseContext { + var p = new(Opt_select_as_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_select_as_clause + + return p +} + +func (s *Opt_select_as_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_select_as_clauseContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Opt_select_as_clauseContext) STRUCT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTRUCT_SYMBOL, 0) +} + +func (s *Opt_select_as_clauseContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Opt_select_as_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_select_as_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_select_as_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_select_as_clause(s) + } +} + +func (s *Opt_select_as_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_select_as_clause(s) + } +} + +func (s *Opt_select_as_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_select_as_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_select_as_clause() (localctx IOpt_select_as_clauseContext) { + localctx = NewOpt_select_as_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 784, GoogleSQLParserRULE_opt_select_as_clause) + p.SetState(4856) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 606, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4852) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4853) + p.Match(GoogleSQLParserSTRUCT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4854) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4855) + p.Path_expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_select_withContext is an interface to support dynamic dispatch. +type IOpt_select_withContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + OPTIONS_SYMBOL() antlr.TerminalNode + Options_list() IOptions_listContext + + // IsOpt_select_withContext differentiates from other interfaces. + IsOpt_select_withContext() +} + +type Opt_select_withContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_select_withContext() *Opt_select_withContext { + var p = new(Opt_select_withContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_select_with + return p +} + +func InitEmptyOpt_select_withContext(p *Opt_select_withContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_select_with +} + +func (*Opt_select_withContext) IsOpt_select_withContext() {} + +func NewOpt_select_withContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_select_withContext { + var p = new(Opt_select_withContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_select_with + + return p +} + +func (s *Opt_select_withContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_select_withContext) WITH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWITH_SYMBOL, 0) +} + +func (s *Opt_select_withContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Opt_select_withContext) OPTIONS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOPTIONS_SYMBOL, 0) +} + +func (s *Opt_select_withContext) Options_list() IOptions_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptions_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptions_listContext) +} + +func (s *Opt_select_withContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_select_withContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_select_withContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_select_with(s) + } +} + +func (s *Opt_select_withContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_select_with(s) + } +} + +func (s *Opt_select_withContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_select_with(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_select_with() (localctx IOpt_select_withContext) { + localctx = NewOpt_select_withContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 786, GoogleSQLParserRULE_opt_select_with) + p.SetState(4865) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 607, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4858) + p.Match(GoogleSQLParserWITH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4859) + p.Identifier() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4860) + p.Match(GoogleSQLParserWITH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4861) + p.Identifier() + } + { + p.SetState(4862) + p.Match(GoogleSQLParserOPTIONS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4863) + p.Options_list() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFrom_clauseContext is an interface to support dynamic dispatch. +type IFrom_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM_SYMBOL() antlr.TerminalNode + From_clause_contents() IFrom_clause_contentsContext + + // IsFrom_clauseContext differentiates from other interfaces. + IsFrom_clauseContext() +} + +type From_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFrom_clauseContext() *From_clauseContext { + var p = new(From_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_from_clause + return p +} + +func InitEmptyFrom_clauseContext(p *From_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_from_clause +} + +func (*From_clauseContext) IsFrom_clauseContext() {} + +func NewFrom_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *From_clauseContext { + var p = new(From_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_from_clause + + return p +} + +func (s *From_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *From_clauseContext) FROM_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFROM_SYMBOL, 0) +} + +func (s *From_clauseContext) From_clause_contents() IFrom_clause_contentsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrom_clause_contentsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrom_clause_contentsContext) +} + +func (s *From_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *From_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *From_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterFrom_clause(s) + } +} + +func (s *From_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitFrom_clause(s) + } +} + +func (s *From_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitFrom_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) From_clause() (localctx IFrom_clauseContext) { + localctx = NewFrom_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 788, GoogleSQLParserRULE_from_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4867) + p.Match(GoogleSQLParserFROM_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4868) + p.From_clause_contents() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFrom_clause_contentsContext is an interface to support dynamic dispatch. +type IFrom_clause_contentsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_primary() ITable_primaryContext + AllFrom_clause_contents_suffix() []IFrom_clause_contents_suffixContext + From_clause_contents_suffix(i int) IFrom_clause_contents_suffixContext + AT_SYMBOL() antlr.TerminalNode + QUESTION_SYMBOL() antlr.TerminalNode + ATAT_SYMBOL() antlr.TerminalNode + + // IsFrom_clause_contentsContext differentiates from other interfaces. + IsFrom_clause_contentsContext() +} + +type From_clause_contentsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFrom_clause_contentsContext() *From_clause_contentsContext { + var p = new(From_clause_contentsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_from_clause_contents + return p +} + +func InitEmptyFrom_clause_contentsContext(p *From_clause_contentsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_from_clause_contents +} + +func (*From_clause_contentsContext) IsFrom_clause_contentsContext() {} + +func NewFrom_clause_contentsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *From_clause_contentsContext { + var p = new(From_clause_contentsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_from_clause_contents + + return p +} + +func (s *From_clause_contentsContext) GetParser() antlr.Parser { return s.parser } + +func (s *From_clause_contentsContext) Table_primary() ITable_primaryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_primaryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_primaryContext) +} + +func (s *From_clause_contentsContext) AllFrom_clause_contents_suffix() []IFrom_clause_contents_suffixContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFrom_clause_contents_suffixContext); ok { + len++ + } + } + + tst := make([]IFrom_clause_contents_suffixContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFrom_clause_contents_suffixContext); ok { + tst[i] = t.(IFrom_clause_contents_suffixContext) + i++ + } + } + + return tst +} + +func (s *From_clause_contentsContext) From_clause_contents_suffix(i int) IFrom_clause_contents_suffixContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrom_clause_contents_suffixContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFrom_clause_contents_suffixContext) +} + +func (s *From_clause_contentsContext) AT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAT_SYMBOL, 0) +} + +func (s *From_clause_contentsContext) QUESTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserQUESTION_SYMBOL, 0) +} + +func (s *From_clause_contentsContext) ATAT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserATAT_SYMBOL, 0) +} + +func (s *From_clause_contentsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *From_clause_contentsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *From_clause_contentsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterFrom_clause_contents(s) + } +} + +func (s *From_clause_contentsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitFrom_clause_contents(s) + } +} + +func (s *From_clause_contentsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitFrom_clause_contents(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) From_clause_contents() (localctx IFrom_clause_contentsContext) { + localctx = NewFrom_clause_contentsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 790, GoogleSQLParserRULE_from_clause_contents) + var _alt int + + p.SetState(4883) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserLR_BRACKET_SYMBOL, GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserUNNEST_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserIF_SYMBOL, GoogleSQLParserSLASH_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4870) + p.table_primary(0) + } + p.SetState(4874) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 608, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(4871) + p.From_clause_contents_suffix() + } + + } + p.SetState(4876) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 608, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case GoogleSQLParserAT_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4877) + p.Match(GoogleSQLParserAT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.NotifyErrorListeners("Query parameters cannot be used in place of table names", nil, nil) + + case GoogleSQLParserQUESTION_SYMBOL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4879) + p.Match(GoogleSQLParserQUESTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.NotifyErrorListeners("Query parameters cannot be used in place of table names", nil, nil) + + case GoogleSQLParserATAT_SYMBOL: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4881) + p.Match(GoogleSQLParserATAT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.NotifyErrorListeners("System variables cannot be used in place of table names", nil, nil) + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFrom_clause_contents_suffixContext is an interface to support dynamic dispatch. +type IFrom_clause_contents_suffixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMA_SYMBOL() antlr.TerminalNode + Table_primary() ITable_primaryContext + JOIN_SYMBOL() antlr.TerminalNode + Opt_natural() IOpt_naturalContext + Join_type() IJoin_typeContext + Join_hint() IJoin_hintContext + Hint() IHintContext + On_or_using_clause_list() IOn_or_using_clause_listContext + + // IsFrom_clause_contents_suffixContext differentiates from other interfaces. + IsFrom_clause_contents_suffixContext() +} + +type From_clause_contents_suffixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFrom_clause_contents_suffixContext() *From_clause_contents_suffixContext { + var p = new(From_clause_contents_suffixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_from_clause_contents_suffix + return p +} + +func InitEmptyFrom_clause_contents_suffixContext(p *From_clause_contents_suffixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_from_clause_contents_suffix +} + +func (*From_clause_contents_suffixContext) IsFrom_clause_contents_suffixContext() {} + +func NewFrom_clause_contents_suffixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *From_clause_contents_suffixContext { + var p = new(From_clause_contents_suffixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_from_clause_contents_suffix + + return p +} + +func (s *From_clause_contents_suffixContext) GetParser() antlr.Parser { return s.parser } + +func (s *From_clause_contents_suffixContext) COMMA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, 0) +} + +func (s *From_clause_contents_suffixContext) Table_primary() ITable_primaryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_primaryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_primaryContext) +} + +func (s *From_clause_contents_suffixContext) JOIN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserJOIN_SYMBOL, 0) +} + +func (s *From_clause_contents_suffixContext) Opt_natural() IOpt_naturalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_naturalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_naturalContext) +} + +func (s *From_clause_contents_suffixContext) Join_type() IJoin_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJoin_typeContext) +} + +func (s *From_clause_contents_suffixContext) Join_hint() IJoin_hintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_hintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJoin_hintContext) +} + +func (s *From_clause_contents_suffixContext) Hint() IHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *From_clause_contents_suffixContext) On_or_using_clause_list() IOn_or_using_clause_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_or_using_clause_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_or_using_clause_listContext) +} + +func (s *From_clause_contents_suffixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *From_clause_contents_suffixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *From_clause_contents_suffixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterFrom_clause_contents_suffix(s) + } +} + +func (s *From_clause_contents_suffixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitFrom_clause_contents_suffix(s) + } +} + +func (s *From_clause_contents_suffixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitFrom_clause_contents_suffix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) From_clause_contents_suffix() (localctx IFrom_clause_contents_suffixContext) { + localctx = NewFrom_clause_contents_suffixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 792, GoogleSQLParserRULE_from_clause_contents_suffix) + var _la int + + p.SetState(4904) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserCOMMA_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4885) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4886) + p.table_primary(0) + } + + case GoogleSQLParserCROSS_SYMBOL, GoogleSQLParserJOIN_SYMBOL, GoogleSQLParserFULL_SYMBOL, GoogleSQLParserINNER_SYMBOL, GoogleSQLParserLEFT_SYMBOL, GoogleSQLParserRIGHT_SYMBOL, GoogleSQLParserHASH_SYMBOL, GoogleSQLParserNATURAL_SYMBOL, GoogleSQLParserLOOKUP_SYMBOL: + p.EnterOuterAlt(localctx, 2) + p.SetState(4888) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserNATURAL_SYMBOL { + { + p.SetState(4887) + p.Opt_natural() + } + + } + p.SetState(4891) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-61)) & ^0x3f) == 0 && ((int64(1)<<(_la-61))&1073825793) != 0 { + { + p.SetState(4890) + p.Join_type() + } + + } + p.SetState(4894) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserHASH_SYMBOL || _la == GoogleSQLParserLOOKUP_SYMBOL { + { + p.SetState(4893) + p.Join_hint() + } + + } + { + p.SetState(4896) + p.Match(GoogleSQLParserJOIN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4898) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(4897) + p.Hint() + } + + } + { + p.SetState(4900) + p.table_primary(0) + } + p.SetState(4902) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 614, p.GetParserRuleContext()) == 1 { + { + p.SetState(4901) + p.On_or_using_clause_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_primaryContext is an interface to support dynamic dispatch. +type ITable_primaryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Tvf_with_suffixes() ITvf_with_suffixesContext + Table_path_expression() ITable_path_expressionContext + LR_BRACKET_SYMBOL() antlr.TerminalNode + Join() IJoinContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + Table_subquery() ITable_subqueryContext + Table_primary() ITable_primaryContext + Match_recognize_clause() IMatch_recognize_clauseContext + Sample_clause() ISample_clauseContext + + // IsTable_primaryContext differentiates from other interfaces. + IsTable_primaryContext() +} + +type Table_primaryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_primaryContext() *Table_primaryContext { + var p = new(Table_primaryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_primary + return p +} + +func InitEmptyTable_primaryContext(p *Table_primaryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_primary +} + +func (*Table_primaryContext) IsTable_primaryContext() {} + +func NewTable_primaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_primaryContext { + var p = new(Table_primaryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_table_primary + + return p +} + +func (s *Table_primaryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_primaryContext) Tvf_with_suffixes() ITvf_with_suffixesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITvf_with_suffixesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITvf_with_suffixesContext) +} + +func (s *Table_primaryContext) Table_path_expression() ITable_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_path_expressionContext) +} + +func (s *Table_primaryContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Table_primaryContext) Join() IJoinContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoinContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJoinContext) +} + +func (s *Table_primaryContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Table_primaryContext) Table_subquery() ITable_subqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_subqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_subqueryContext) +} + +func (s *Table_primaryContext) Table_primary() ITable_primaryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_primaryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_primaryContext) +} + +func (s *Table_primaryContext) Match_recognize_clause() IMatch_recognize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMatch_recognize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMatch_recognize_clauseContext) +} + +func (s *Table_primaryContext) Sample_clause() ISample_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISample_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISample_clauseContext) +} + +func (s *Table_primaryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_primaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_primaryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTable_primary(s) + } +} + +func (s *Table_primaryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTable_primary(s) + } +} + +func (s *Table_primaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTable_primary(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Table_primary() (localctx ITable_primaryContext) { + return p.table_primary(0) +} + +func (p *GoogleSQLParser) table_primary(_p int) (localctx ITable_primaryContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewTable_primaryContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx ITable_primaryContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 794 + p.EnterRecursionRule(localctx, 794, GoogleSQLParserRULE_table_primary, _p) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4914) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 616, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4907) + p.Tvf_with_suffixes() + } + + case 2: + { + p.SetState(4908) + p.Table_path_expression() + } + + case 3: + { + p.SetState(4909) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4910) + p.Join() + } + { + p.SetState(4911) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(4913) + p.Table_subquery() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(4922) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 618, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + p.SetState(4920) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 617, p.GetParserRuleContext()) { + case 1: + localctx = NewTable_primaryContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_table_primary) + p.SetState(4916) + + if !(p.Precpred(p.GetParserRuleContext(), 2)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) + goto errorExit + } + { + p.SetState(4917) + p.Match_recognize_clause() + } + + case 2: + localctx = NewTable_primaryContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_table_primary) + p.SetState(4918) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(4919) + p.Sample_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(4924) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 618, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITvf_with_suffixesContext is an interface to support dynamic dispatch. +type ITvf_with_suffixesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Tvf_prefix_no_args() ITvf_prefix_no_argsContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + Hint() IHintContext + Pivot_or_unpivot_clause_and_aliases() IPivot_or_unpivot_clause_and_aliasesContext + Tvf_prefix() ITvf_prefixContext + + // IsTvf_with_suffixesContext differentiates from other interfaces. + IsTvf_with_suffixesContext() +} + +type Tvf_with_suffixesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTvf_with_suffixesContext() *Tvf_with_suffixesContext { + var p = new(Tvf_with_suffixesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_tvf_with_suffixes + return p +} + +func InitEmptyTvf_with_suffixesContext(p *Tvf_with_suffixesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_tvf_with_suffixes +} + +func (*Tvf_with_suffixesContext) IsTvf_with_suffixesContext() {} + +func NewTvf_with_suffixesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tvf_with_suffixesContext { + var p = new(Tvf_with_suffixesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_tvf_with_suffixes + + return p +} + +func (s *Tvf_with_suffixesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tvf_with_suffixesContext) Tvf_prefix_no_args() ITvf_prefix_no_argsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITvf_prefix_no_argsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITvf_prefix_no_argsContext) +} + +func (s *Tvf_with_suffixesContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Tvf_with_suffixesContext) Hint() IHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Tvf_with_suffixesContext) Pivot_or_unpivot_clause_and_aliases() IPivot_or_unpivot_clause_and_aliasesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_or_unpivot_clause_and_aliasesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPivot_or_unpivot_clause_and_aliasesContext) +} + +func (s *Tvf_with_suffixesContext) Tvf_prefix() ITvf_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITvf_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITvf_prefixContext) +} + +func (s *Tvf_with_suffixesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tvf_with_suffixesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tvf_with_suffixesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTvf_with_suffixes(s) + } +} + +func (s *Tvf_with_suffixesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTvf_with_suffixes(s) + } +} + +func (s *Tvf_with_suffixesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTvf_with_suffixes(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Tvf_with_suffixes() (localctx ITvf_with_suffixesContext) { + localctx = NewTvf_with_suffixesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 796, GoogleSQLParserRULE_tvf_with_suffixes) + p.SetState(4941) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 623, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4925) + p.Tvf_prefix_no_args() + } + { + p.SetState(4926) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4928) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 619, p.GetParserRuleContext()) == 1 { + { + p.SetState(4927) + p.Hint() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4931) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 620, p.GetParserRuleContext()) == 1 { + { + p.SetState(4930) + p.Pivot_or_unpivot_clause_and_aliases() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4933) + p.Tvf_prefix() + } + { + p.SetState(4934) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4936) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 621, p.GetParserRuleContext()) == 1 { + { + p.SetState(4935) + p.Hint() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4939) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 622, p.GetParserRuleContext()) == 1 { + { + p.SetState(4938) + p.Pivot_or_unpivot_clause_and_aliases() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPivot_or_unpivot_clause_and_aliasesContext is an interface to support dynamic dispatch. +type IPivot_or_unpivot_clause_and_aliasesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AS_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + Pivot_clause() IPivot_clauseContext + As_alias() IAs_aliasContext + Unpivot_clause() IUnpivot_clauseContext + Qualify_clause_nonreserved() IQualify_clause_nonreservedContext + + // IsPivot_or_unpivot_clause_and_aliasesContext differentiates from other interfaces. + IsPivot_or_unpivot_clause_and_aliasesContext() +} + +type Pivot_or_unpivot_clause_and_aliasesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPivot_or_unpivot_clause_and_aliasesContext() *Pivot_or_unpivot_clause_and_aliasesContext { + var p = new(Pivot_or_unpivot_clause_and_aliasesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_pivot_or_unpivot_clause_and_aliases + return p +} + +func InitEmptyPivot_or_unpivot_clause_and_aliasesContext(p *Pivot_or_unpivot_clause_and_aliasesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_pivot_or_unpivot_clause_and_aliases +} + +func (*Pivot_or_unpivot_clause_and_aliasesContext) IsPivot_or_unpivot_clause_and_aliasesContext() {} + +func NewPivot_or_unpivot_clause_and_aliasesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pivot_or_unpivot_clause_and_aliasesContext { + var p = new(Pivot_or_unpivot_clause_and_aliasesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_pivot_or_unpivot_clause_and_aliases + + return p +} + +func (s *Pivot_or_unpivot_clause_and_aliasesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pivot_or_unpivot_clause_and_aliasesContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Pivot_or_unpivot_clause_and_aliasesContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Pivot_or_unpivot_clause_and_aliasesContext) Pivot_clause() IPivot_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPivot_clauseContext) +} + +func (s *Pivot_or_unpivot_clause_and_aliasesContext) As_alias() IAs_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_aliasContext) +} + +func (s *Pivot_or_unpivot_clause_and_aliasesContext) Unpivot_clause() IUnpivot_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnpivot_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnpivot_clauseContext) +} + +func (s *Pivot_or_unpivot_clause_and_aliasesContext) Qualify_clause_nonreserved() IQualify_clause_nonreservedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualify_clause_nonreservedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualify_clause_nonreservedContext) +} + +func (s *Pivot_or_unpivot_clause_and_aliasesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pivot_or_unpivot_clause_and_aliasesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pivot_or_unpivot_clause_and_aliasesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPivot_or_unpivot_clause_and_aliases(s) + } +} + +func (s *Pivot_or_unpivot_clause_and_aliasesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPivot_or_unpivot_clause_and_aliases(s) + } +} + +func (s *Pivot_or_unpivot_clause_and_aliasesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPivot_or_unpivot_clause_and_aliases(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Pivot_or_unpivot_clause_and_aliases() (localctx IPivot_or_unpivot_clause_and_aliasesContext) { + localctx = NewPivot_or_unpivot_clause_and_aliasesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 798, GoogleSQLParserRULE_pivot_or_unpivot_clause_and_aliases) + p.SetState(4986) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 628, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4943) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4944) + p.Identifier() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4945) + p.Identifier() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4946) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4947) + p.Identifier() + } + { + p.SetState(4948) + p.Pivot_clause() + } + p.SetState(4950) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 624, p.GetParserRuleContext()) == 1 { + { + p.SetState(4949) + p.As_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4952) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4953) + p.Identifier() + } + { + p.SetState(4954) + p.Unpivot_clause() + } + p.SetState(4956) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 625, p.GetParserRuleContext()) == 1 { + { + p.SetState(4955) + p.As_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(4958) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4959) + p.Identifier() + } + { + p.SetState(4960) + p.Qualify_clause_nonreserved() + } + + p.NotifyErrorListeners("QUALIFY clause must be used in conjunction with WHERE or GROUP BY or HAVING clause", nil, nil) + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(4963) + p.Identifier() + } + { + p.SetState(4964) + p.Pivot_clause() + } + { + p.SetState(4965) + p.As_alias() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(4967) + p.Identifier() + } + { + p.SetState(4968) + p.Unpivot_clause() + } + { + p.SetState(4969) + p.As_alias() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(4971) + p.Identifier() + } + { + p.SetState(4972) + p.Qualify_clause_nonreserved() + } + + p.NotifyErrorListeners("QUALIFY clause must be used in conjunction with WHERE or GROUP BY or HAVING clause", nil, nil) + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(4975) + p.Pivot_clause() + } + p.SetState(4977) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 626, p.GetParserRuleContext()) == 1 { + { + p.SetState(4976) + p.As_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(4979) + p.Unpivot_clause() + } + p.SetState(4981) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 627, p.GetParserRuleContext()) == 1 { + { + p.SetState(4980) + p.As_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(4983) + p.Qualify_clause_nonreserved() + } + + p.NotifyErrorListeners("QUALIFY clause must be used in conjunction with WHERE or GROUP BY or HAVING clause", nil, nil) + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAs_aliasContext is an interface to support dynamic dispatch. +type IAs_aliasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + AS_SYMBOL() antlr.TerminalNode + + // IsAs_aliasContext differentiates from other interfaces. + IsAs_aliasContext() +} + +type As_aliasContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAs_aliasContext() *As_aliasContext { + var p = new(As_aliasContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_as_alias + return p +} + +func InitEmptyAs_aliasContext(p *As_aliasContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_as_alias +} + +func (*As_aliasContext) IsAs_aliasContext() {} + +func NewAs_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *As_aliasContext { + var p = new(As_aliasContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_as_alias + + return p +} + +func (s *As_aliasContext) GetParser() antlr.Parser { return s.parser } + +func (s *As_aliasContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *As_aliasContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *As_aliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *As_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *As_aliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterAs_alias(s) + } +} + +func (s *As_aliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitAs_alias(s) + } +} + +func (s *As_aliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitAs_alias(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) As_alias() (localctx IAs_aliasContext) { + localctx = NewAs_aliasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 800, GoogleSQLParserRULE_as_alias) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4989) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(4988) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4991) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISample_clauseContext is an interface to support dynamic dispatch. +type ISample_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLESAMPLE_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + LR_BRACKET_SYMBOL() antlr.TerminalNode + Sample_size() ISample_sizeContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + Opt_sample_clause_suffix() IOpt_sample_clause_suffixContext + + // IsSample_clauseContext differentiates from other interfaces. + IsSample_clauseContext() +} + +type Sample_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySample_clauseContext() *Sample_clauseContext { + var p = new(Sample_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_sample_clause + return p +} + +func InitEmptySample_clauseContext(p *Sample_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_sample_clause +} + +func (*Sample_clauseContext) IsSample_clauseContext() {} + +func NewSample_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sample_clauseContext { + var p = new(Sample_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_sample_clause + + return p +} + +func (s *Sample_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sample_clauseContext) TABLESAMPLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTABLESAMPLE_SYMBOL, 0) +} + +func (s *Sample_clauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Sample_clauseContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Sample_clauseContext) Sample_size() ISample_sizeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISample_sizeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISample_sizeContext) +} + +func (s *Sample_clauseContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Sample_clauseContext) Opt_sample_clause_suffix() IOpt_sample_clause_suffixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_sample_clause_suffixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_sample_clause_suffixContext) +} + +func (s *Sample_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sample_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sample_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSample_clause(s) + } +} + +func (s *Sample_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSample_clause(s) + } +} + +func (s *Sample_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSample_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Sample_clause() (localctx ISample_clauseContext) { + localctx = NewSample_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 802, GoogleSQLParserRULE_sample_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4993) + p.Match(GoogleSQLParserTABLESAMPLE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4994) + p.Identifier() + } + { + p.SetState(4995) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4996) + p.Sample_size() + } + { + p.SetState(4997) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4998) + p.Opt_sample_clause_suffix() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_sample_clause_suffixContext is an interface to support dynamic dispatch. +type IOpt_sample_clause_suffixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Repeatable_clause() IRepeatable_clauseContext + WITH_SYMBOL() antlr.TerminalNode + WEIGHT_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + AS_SYMBOL() antlr.TerminalNode + + // IsOpt_sample_clause_suffixContext differentiates from other interfaces. + IsOpt_sample_clause_suffixContext() +} + +type Opt_sample_clause_suffixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_sample_clause_suffixContext() *Opt_sample_clause_suffixContext { + var p = new(Opt_sample_clause_suffixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_sample_clause_suffix + return p +} + +func InitEmptyOpt_sample_clause_suffixContext(p *Opt_sample_clause_suffixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_sample_clause_suffix +} + +func (*Opt_sample_clause_suffixContext) IsOpt_sample_clause_suffixContext() {} + +func NewOpt_sample_clause_suffixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_sample_clause_suffixContext { + var p = new(Opt_sample_clause_suffixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_sample_clause_suffix + + return p +} + +func (s *Opt_sample_clause_suffixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_sample_clause_suffixContext) Repeatable_clause() IRepeatable_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRepeatable_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRepeatable_clauseContext) +} + +func (s *Opt_sample_clause_suffixContext) WITH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWITH_SYMBOL, 0) +} + +func (s *Opt_sample_clause_suffixContext) WEIGHT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWEIGHT_SYMBOL, 0) +} + +func (s *Opt_sample_clause_suffixContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Opt_sample_clause_suffixContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Opt_sample_clause_suffixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_sample_clause_suffixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_sample_clause_suffixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_sample_clause_suffix(s) + } +} + +func (s *Opt_sample_clause_suffixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_sample_clause_suffix(s) + } +} + +func (s *Opt_sample_clause_suffixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_sample_clause_suffix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_sample_clause_suffix() (localctx IOpt_sample_clause_suffixContext) { + localctx = NewOpt_sample_clause_suffixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 804, GoogleSQLParserRULE_opt_sample_clause_suffix) + p.SetState(5019) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 633, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5000) + p.Repeatable_clause() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5001) + p.Match(GoogleSQLParserWITH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5002) + p.Match(GoogleSQLParserWEIGHT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5004) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 630, p.GetParserRuleContext()) == 1 { + { + p.SetState(5003) + p.Repeatable_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5006) + p.Match(GoogleSQLParserWITH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5007) + p.Match(GoogleSQLParserWEIGHT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5008) + p.Identifier() + } + p.SetState(5010) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 631, p.GetParserRuleContext()) == 1 { + { + p.SetState(5009) + p.Repeatable_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5012) + p.Match(GoogleSQLParserWITH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5013) + p.Match(GoogleSQLParserWEIGHT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5014) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5015) + p.Identifier() + } + p.SetState(5017) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 632, p.GetParserRuleContext()) == 1 { + { + p.SetState(5016) + p.Repeatable_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRepeatable_clauseContext is an interface to support dynamic dispatch. +type IRepeatable_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REPEATABLE_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + Possibly_cast_int_literal_or_parameter() IPossibly_cast_int_literal_or_parameterContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsRepeatable_clauseContext differentiates from other interfaces. + IsRepeatable_clauseContext() +} + +type Repeatable_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRepeatable_clauseContext() *Repeatable_clauseContext { + var p = new(Repeatable_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_repeatable_clause + return p +} + +func InitEmptyRepeatable_clauseContext(p *Repeatable_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_repeatable_clause +} + +func (*Repeatable_clauseContext) IsRepeatable_clauseContext() {} + +func NewRepeatable_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Repeatable_clauseContext { + var p = new(Repeatable_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_repeatable_clause + + return p +} + +func (s *Repeatable_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Repeatable_clauseContext) REPEATABLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREPEATABLE_SYMBOL, 0) +} + +func (s *Repeatable_clauseContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Repeatable_clauseContext) Possibly_cast_int_literal_or_parameter() IPossibly_cast_int_literal_or_parameterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPossibly_cast_int_literal_or_parameterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPossibly_cast_int_literal_or_parameterContext) +} + +func (s *Repeatable_clauseContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Repeatable_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Repeatable_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Repeatable_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterRepeatable_clause(s) + } +} + +func (s *Repeatable_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitRepeatable_clause(s) + } +} + +func (s *Repeatable_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitRepeatable_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Repeatable_clause() (localctx IRepeatable_clauseContext) { + localctx = NewRepeatable_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 806, GoogleSQLParserRULE_repeatable_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5021) + p.Match(GoogleSQLParserREPEATABLE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5022) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5023) + p.Possibly_cast_int_literal_or_parameter() + } + { + p.SetState(5024) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPossibly_cast_int_literal_or_parameterContext is an interface to support dynamic dispatch. +type IPossibly_cast_int_literal_or_parameterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Cast_int_literal_or_parameter() ICast_int_literal_or_parameterContext + Int_literal_or_parameter() IInt_literal_or_parameterContext + + // IsPossibly_cast_int_literal_or_parameterContext differentiates from other interfaces. + IsPossibly_cast_int_literal_or_parameterContext() +} + +type Possibly_cast_int_literal_or_parameterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPossibly_cast_int_literal_or_parameterContext() *Possibly_cast_int_literal_or_parameterContext { + var p = new(Possibly_cast_int_literal_or_parameterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_possibly_cast_int_literal_or_parameter + return p +} + +func InitEmptyPossibly_cast_int_literal_or_parameterContext(p *Possibly_cast_int_literal_or_parameterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_possibly_cast_int_literal_or_parameter +} + +func (*Possibly_cast_int_literal_or_parameterContext) IsPossibly_cast_int_literal_or_parameterContext() { +} + +func NewPossibly_cast_int_literal_or_parameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Possibly_cast_int_literal_or_parameterContext { + var p = new(Possibly_cast_int_literal_or_parameterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_possibly_cast_int_literal_or_parameter + + return p +} + +func (s *Possibly_cast_int_literal_or_parameterContext) GetParser() antlr.Parser { return s.parser } + +func (s *Possibly_cast_int_literal_or_parameterContext) Cast_int_literal_or_parameter() ICast_int_literal_or_parameterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICast_int_literal_or_parameterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICast_int_literal_or_parameterContext) +} + +func (s *Possibly_cast_int_literal_or_parameterContext) Int_literal_or_parameter() IInt_literal_or_parameterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInt_literal_or_parameterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInt_literal_or_parameterContext) +} + +func (s *Possibly_cast_int_literal_or_parameterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Possibly_cast_int_literal_or_parameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Possibly_cast_int_literal_or_parameterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPossibly_cast_int_literal_or_parameter(s) + } +} + +func (s *Possibly_cast_int_literal_or_parameterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPossibly_cast_int_literal_or_parameter(s) + } +} + +func (s *Possibly_cast_int_literal_or_parameterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPossibly_cast_int_literal_or_parameter(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Possibly_cast_int_literal_or_parameter() (localctx IPossibly_cast_int_literal_or_parameterContext) { + localctx = NewPossibly_cast_int_literal_or_parameterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 808, GoogleSQLParserRULE_possibly_cast_int_literal_or_parameter) + p.SetState(5028) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserCAST_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5026) + p.Cast_int_literal_or_parameter() + } + + case GoogleSQLParserQUESTION_SYMBOL, GoogleSQLParserAT_SYMBOL, GoogleSQLParserATAT_SYMBOL, GoogleSQLParserINTEGER_LITERAL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5027) + p.Int_literal_or_parameter() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICast_int_literal_or_parameterContext is an interface to support dynamic dispatch. +type ICast_int_literal_or_parameterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CAST_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + Int_literal_or_parameter() IInt_literal_or_parameterContext + AS_SYMBOL() antlr.TerminalNode + Type_() ITypeContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + Opt_format() IOpt_formatContext + + // IsCast_int_literal_or_parameterContext differentiates from other interfaces. + IsCast_int_literal_or_parameterContext() +} + +type Cast_int_literal_or_parameterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCast_int_literal_or_parameterContext() *Cast_int_literal_or_parameterContext { + var p = new(Cast_int_literal_or_parameterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_cast_int_literal_or_parameter + return p +} + +func InitEmptyCast_int_literal_or_parameterContext(p *Cast_int_literal_or_parameterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_cast_int_literal_or_parameter +} + +func (*Cast_int_literal_or_parameterContext) IsCast_int_literal_or_parameterContext() {} + +func NewCast_int_literal_or_parameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cast_int_literal_or_parameterContext { + var p = new(Cast_int_literal_or_parameterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_cast_int_literal_or_parameter + + return p +} + +func (s *Cast_int_literal_or_parameterContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cast_int_literal_or_parameterContext) CAST_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCAST_SYMBOL, 0) +} + +func (s *Cast_int_literal_or_parameterContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Cast_int_literal_or_parameterContext) Int_literal_or_parameter() IInt_literal_or_parameterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInt_literal_or_parameterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInt_literal_or_parameterContext) +} + +func (s *Cast_int_literal_or_parameterContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Cast_int_literal_or_parameterContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *Cast_int_literal_or_parameterContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Cast_int_literal_or_parameterContext) Opt_format() IOpt_formatContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_formatContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_formatContext) +} + +func (s *Cast_int_literal_or_parameterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cast_int_literal_or_parameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cast_int_literal_or_parameterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCast_int_literal_or_parameter(s) + } +} + +func (s *Cast_int_literal_or_parameterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCast_int_literal_or_parameter(s) + } +} + +func (s *Cast_int_literal_or_parameterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCast_int_literal_or_parameter(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Cast_int_literal_or_parameter() (localctx ICast_int_literal_or_parameterContext) { + localctx = NewCast_int_literal_or_parameterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 810, GoogleSQLParserRULE_cast_int_literal_or_parameter) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5030) + p.Match(GoogleSQLParserCAST_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5031) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5032) + p.Int_literal_or_parameter() + } + { + p.SetState(5033) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5034) + p.Type_() + } + p.SetState(5036) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserFORMAT_SYMBOL { + { + p.SetState(5035) + p.Opt_format() + } + + } + { + p.SetState(5038) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISample_sizeContext is an interface to support dynamic dispatch. +type ISample_sizeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Sample_size_value() ISample_size_valueContext + Sample_size_unit() ISample_size_unitContext + Partition_by_clause_prefix_no_hint() IPartition_by_clause_prefix_no_hintContext + + // IsSample_sizeContext differentiates from other interfaces. + IsSample_sizeContext() +} + +type Sample_sizeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySample_sizeContext() *Sample_sizeContext { + var p = new(Sample_sizeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_sample_size + return p +} + +func InitEmptySample_sizeContext(p *Sample_sizeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_sample_size +} + +func (*Sample_sizeContext) IsSample_sizeContext() {} + +func NewSample_sizeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sample_sizeContext { + var p = new(Sample_sizeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_sample_size + + return p +} + +func (s *Sample_sizeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sample_sizeContext) Sample_size_value() ISample_size_valueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISample_size_valueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISample_size_valueContext) +} + +func (s *Sample_sizeContext) Sample_size_unit() ISample_size_unitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISample_size_unitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISample_size_unitContext) +} + +func (s *Sample_sizeContext) Partition_by_clause_prefix_no_hint() IPartition_by_clause_prefix_no_hintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_by_clause_prefix_no_hintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_by_clause_prefix_no_hintContext) +} + +func (s *Sample_sizeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sample_sizeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sample_sizeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSample_size(s) + } +} + +func (s *Sample_sizeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSample_size(s) + } +} + +func (s *Sample_sizeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSample_size(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Sample_size() (localctx ISample_sizeContext) { + localctx = NewSample_sizeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 812, GoogleSQLParserRULE_sample_size) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5040) + p.Sample_size_value() + } + { + p.SetState(5041) + p.Sample_size_unit() + } + p.SetState(5043) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserPARTITION_SYMBOL { + { + p.SetState(5042) + p.Partition_by_clause_prefix_no_hint() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISample_size_valueContext is an interface to support dynamic dispatch. +type ISample_size_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Possibly_cast_int_literal_or_parameter() IPossibly_cast_int_literal_or_parameterContext + Floating_point_literal() IFloating_point_literalContext + + // IsSample_size_valueContext differentiates from other interfaces. + IsSample_size_valueContext() +} + +type Sample_size_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySample_size_valueContext() *Sample_size_valueContext { + var p = new(Sample_size_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_sample_size_value + return p +} + +func InitEmptySample_size_valueContext(p *Sample_size_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_sample_size_value +} + +func (*Sample_size_valueContext) IsSample_size_valueContext() {} + +func NewSample_size_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sample_size_valueContext { + var p = new(Sample_size_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_sample_size_value + + return p +} + +func (s *Sample_size_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sample_size_valueContext) Possibly_cast_int_literal_or_parameter() IPossibly_cast_int_literal_or_parameterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPossibly_cast_int_literal_or_parameterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPossibly_cast_int_literal_or_parameterContext) +} + +func (s *Sample_size_valueContext) Floating_point_literal() IFloating_point_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFloating_point_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFloating_point_literalContext) +} + +func (s *Sample_size_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sample_size_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sample_size_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSample_size_value(s) + } +} + +func (s *Sample_size_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSample_size_value(s) + } +} + +func (s *Sample_size_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSample_size_value(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Sample_size_value() (localctx ISample_size_valueContext) { + localctx = NewSample_size_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 814, GoogleSQLParserRULE_sample_size_value) + p.SetState(5047) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserQUESTION_SYMBOL, GoogleSQLParserAT_SYMBOL, GoogleSQLParserATAT_SYMBOL, GoogleSQLParserINTEGER_LITERAL, GoogleSQLParserCAST_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5045) + p.Possibly_cast_int_literal_or_parameter() + } + + case GoogleSQLParserFLOATING_POINT_LITERAL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5046) + p.Floating_point_literal() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISample_size_unitContext is an interface to support dynamic dispatch. +type ISample_size_unitContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROWS_SYMBOL() antlr.TerminalNode + PERCENT_SYMBOL() antlr.TerminalNode + + // IsSample_size_unitContext differentiates from other interfaces. + IsSample_size_unitContext() +} + +type Sample_size_unitContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySample_size_unitContext() *Sample_size_unitContext { + var p = new(Sample_size_unitContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_sample_size_unit + return p +} + +func InitEmptySample_size_unitContext(p *Sample_size_unitContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_sample_size_unit +} + +func (*Sample_size_unitContext) IsSample_size_unitContext() {} + +func NewSample_size_unitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sample_size_unitContext { + var p = new(Sample_size_unitContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_sample_size_unit + + return p +} + +func (s *Sample_size_unitContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sample_size_unitContext) ROWS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserROWS_SYMBOL, 0) +} + +func (s *Sample_size_unitContext) PERCENT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPERCENT_SYMBOL, 0) +} + +func (s *Sample_size_unitContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sample_size_unitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sample_size_unitContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSample_size_unit(s) + } +} + +func (s *Sample_size_unitContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSample_size_unit(s) + } +} + +func (s *Sample_size_unitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSample_size_unit(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Sample_size_unit() (localctx ISample_size_unitContext) { + localctx = NewSample_size_unitContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 816, GoogleSQLParserRULE_sample_size_unit) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5049) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserPERCENT_SYMBOL || _la == GoogleSQLParserROWS_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartition_by_clause_prefix_no_hintContext is an interface to support dynamic dispatch. +type IPartition_by_clause_prefix_no_hintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION_SYMBOL() antlr.TerminalNode + BY_SYMBOL() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsPartition_by_clause_prefix_no_hintContext differentiates from other interfaces. + IsPartition_by_clause_prefix_no_hintContext() +} + +type Partition_by_clause_prefix_no_hintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartition_by_clause_prefix_no_hintContext() *Partition_by_clause_prefix_no_hintContext { + var p = new(Partition_by_clause_prefix_no_hintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_partition_by_clause_prefix_no_hint + return p +} + +func InitEmptyPartition_by_clause_prefix_no_hintContext(p *Partition_by_clause_prefix_no_hintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_partition_by_clause_prefix_no_hint +} + +func (*Partition_by_clause_prefix_no_hintContext) IsPartition_by_clause_prefix_no_hintContext() {} + +func NewPartition_by_clause_prefix_no_hintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_by_clause_prefix_no_hintContext { + var p = new(Partition_by_clause_prefix_no_hintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_partition_by_clause_prefix_no_hint + + return p +} + +func (s *Partition_by_clause_prefix_no_hintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partition_by_clause_prefix_no_hintContext) PARTITION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPARTITION_SYMBOL, 0) +} + +func (s *Partition_by_clause_prefix_no_hintContext) BY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBY_SYMBOL, 0) +} + +func (s *Partition_by_clause_prefix_no_hintContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Partition_by_clause_prefix_no_hintContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Partition_by_clause_prefix_no_hintContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Partition_by_clause_prefix_no_hintContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Partition_by_clause_prefix_no_hintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partition_by_clause_prefix_no_hintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partition_by_clause_prefix_no_hintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPartition_by_clause_prefix_no_hint(s) + } +} + +func (s *Partition_by_clause_prefix_no_hintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPartition_by_clause_prefix_no_hint(s) + } +} + +func (s *Partition_by_clause_prefix_no_hintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPartition_by_clause_prefix_no_hint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Partition_by_clause_prefix_no_hint() (localctx IPartition_by_clause_prefix_no_hintContext) { + localctx = NewPartition_by_clause_prefix_no_hintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 818, GoogleSQLParserRULE_partition_by_clause_prefix_no_hint) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5051) + p.Match(GoogleSQLParserPARTITION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5052) + p.Match(GoogleSQLParserBY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5053) + p.expression(0) + } + p.SetState(5058) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(5054) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5055) + p.expression(0) + } + + p.SetState(5060) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMatch_recognize_clauseContext is an interface to support dynamic dispatch. +type IMatch_recognize_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MATCH_RECOGNIZE_SYMBOL() antlr.TerminalNode + AllLR_BRACKET_SYMBOL() []antlr.TerminalNode + LR_BRACKET_SYMBOL(i int) antlr.TerminalNode + Order_by_clause() IOrder_by_clauseContext + MEASURES_SYMBOL() antlr.TerminalNode + Select_list_prefix_with_as_aliases() ISelect_list_prefix_with_as_aliasesContext + PATTERN_SYMBOL() antlr.TerminalNode + Row_pattern_expr() IRow_pattern_exprContext + AllRR_BRACKET_SYMBOL() []antlr.TerminalNode + RR_BRACKET_SYMBOL(i int) antlr.TerminalNode + DEFINE_SYMBOL() antlr.TerminalNode + With_expression_variable_prefix() IWith_expression_variable_prefixContext + Partition_by_clause_prefix() IPartition_by_clause_prefixContext + As_alias() IAs_aliasContext + + // IsMatch_recognize_clauseContext differentiates from other interfaces. + IsMatch_recognize_clauseContext() +} + +type Match_recognize_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMatch_recognize_clauseContext() *Match_recognize_clauseContext { + var p = new(Match_recognize_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_match_recognize_clause + return p +} + +func InitEmptyMatch_recognize_clauseContext(p *Match_recognize_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_match_recognize_clause +} + +func (*Match_recognize_clauseContext) IsMatch_recognize_clauseContext() {} + +func NewMatch_recognize_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Match_recognize_clauseContext { + var p = new(Match_recognize_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_match_recognize_clause + + return p +} + +func (s *Match_recognize_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Match_recognize_clauseContext) MATCH_RECOGNIZE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMATCH_RECOGNIZE_SYMBOL, 0) +} + +func (s *Match_recognize_clauseContext) AllLR_BRACKET_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserLR_BRACKET_SYMBOL) +} + +func (s *Match_recognize_clauseContext) LR_BRACKET_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, i) +} + +func (s *Match_recognize_clauseContext) Order_by_clause() IOrder_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_clauseContext) +} + +func (s *Match_recognize_clauseContext) MEASURES_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMEASURES_SYMBOL, 0) +} + +func (s *Match_recognize_clauseContext) Select_list_prefix_with_as_aliases() ISelect_list_prefix_with_as_aliasesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_list_prefix_with_as_aliasesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_list_prefix_with_as_aliasesContext) +} + +func (s *Match_recognize_clauseContext) PATTERN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPATTERN_SYMBOL, 0) +} + +func (s *Match_recognize_clauseContext) Row_pattern_expr() IRow_pattern_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRow_pattern_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRow_pattern_exprContext) +} + +func (s *Match_recognize_clauseContext) AllRR_BRACKET_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserRR_BRACKET_SYMBOL) +} + +func (s *Match_recognize_clauseContext) RR_BRACKET_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, i) +} + +func (s *Match_recognize_clauseContext) DEFINE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDEFINE_SYMBOL, 0) +} + +func (s *Match_recognize_clauseContext) With_expression_variable_prefix() IWith_expression_variable_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_expression_variable_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_expression_variable_prefixContext) +} + +func (s *Match_recognize_clauseContext) Partition_by_clause_prefix() IPartition_by_clause_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_by_clause_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_by_clause_prefixContext) +} + +func (s *Match_recognize_clauseContext) As_alias() IAs_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_aliasContext) +} + +func (s *Match_recognize_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Match_recognize_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Match_recognize_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterMatch_recognize_clause(s) + } +} + +func (s *Match_recognize_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitMatch_recognize_clause(s) + } +} + +func (s *Match_recognize_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitMatch_recognize_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Match_recognize_clause() (localctx IMatch_recognize_clauseContext) { + localctx = NewMatch_recognize_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 820, GoogleSQLParserRULE_match_recognize_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5061) + p.Match(GoogleSQLParserMATCH_RECOGNIZE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5062) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5064) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserPARTITION_SYMBOL { + { + p.SetState(5063) + p.Partition_by_clause_prefix() + } + + } + { + p.SetState(5066) + p.Order_by_clause() + } + { + p.SetState(5067) + p.Match(GoogleSQLParserMEASURES_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5068) + p.Select_list_prefix_with_as_aliases() + } + { + p.SetState(5069) + p.Match(GoogleSQLParserPATTERN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5070) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5071) + p.row_pattern_expr(0) + } + { + p.SetState(5072) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5073) + p.Match(GoogleSQLParserDEFINE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5074) + p.With_expression_variable_prefix() + } + { + p.SetState(5075) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5077) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 640, p.GetParserRuleContext()) == 1 { + { + p.SetState(5076) + p.As_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRow_pattern_exprContext is an interface to support dynamic dispatch. +type IRow_pattern_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Row_pattern_concatenation() IRow_pattern_concatenationContext + Row_pattern_expr() IRow_pattern_exprContext + STROKE_SYMBOL() antlr.TerminalNode + + // IsRow_pattern_exprContext differentiates from other interfaces. + IsRow_pattern_exprContext() +} + +type Row_pattern_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRow_pattern_exprContext() *Row_pattern_exprContext { + var p = new(Row_pattern_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_row_pattern_expr + return p +} + +func InitEmptyRow_pattern_exprContext(p *Row_pattern_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_row_pattern_expr +} + +func (*Row_pattern_exprContext) IsRow_pattern_exprContext() {} + +func NewRow_pattern_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Row_pattern_exprContext { + var p = new(Row_pattern_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_row_pattern_expr + + return p +} + +func (s *Row_pattern_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *Row_pattern_exprContext) Row_pattern_concatenation() IRow_pattern_concatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRow_pattern_concatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRow_pattern_concatenationContext) +} + +func (s *Row_pattern_exprContext) Row_pattern_expr() IRow_pattern_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRow_pattern_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRow_pattern_exprContext) +} + +func (s *Row_pattern_exprContext) STROKE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTROKE_SYMBOL, 0) +} + +func (s *Row_pattern_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Row_pattern_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Row_pattern_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterRow_pattern_expr(s) + } +} + +func (s *Row_pattern_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitRow_pattern_expr(s) + } +} + +func (s *Row_pattern_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitRow_pattern_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Row_pattern_expr() (localctx IRow_pattern_exprContext) { + return p.row_pattern_expr(0) +} + +func (p *GoogleSQLParser) row_pattern_expr(_p int) (localctx IRow_pattern_exprContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewRow_pattern_exprContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IRow_pattern_exprContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 822 + p.EnterRecursionRule(localctx, 822, GoogleSQLParserRULE_row_pattern_expr, _p) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5080) + p.row_pattern_concatenation(0) + } + + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(5087) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 641, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + localctx = NewRow_pattern_exprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_row_pattern_expr) + p.SetState(5082) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(5083) + p.Match(GoogleSQLParserSTROKE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5084) + p.row_pattern_concatenation(0) + } + + } + p.SetState(5089) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 641, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRow_pattern_concatenationContext is an interface to support dynamic dispatch. +type IRow_pattern_concatenationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Row_pattern_factor() IRow_pattern_factorContext + Row_pattern_concatenation() IRow_pattern_concatenationContext + + // IsRow_pattern_concatenationContext differentiates from other interfaces. + IsRow_pattern_concatenationContext() +} + +type Row_pattern_concatenationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRow_pattern_concatenationContext() *Row_pattern_concatenationContext { + var p = new(Row_pattern_concatenationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_row_pattern_concatenation + return p +} + +func InitEmptyRow_pattern_concatenationContext(p *Row_pattern_concatenationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_row_pattern_concatenation +} + +func (*Row_pattern_concatenationContext) IsRow_pattern_concatenationContext() {} + +func NewRow_pattern_concatenationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Row_pattern_concatenationContext { + var p = new(Row_pattern_concatenationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_row_pattern_concatenation + + return p +} + +func (s *Row_pattern_concatenationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Row_pattern_concatenationContext) Row_pattern_factor() IRow_pattern_factorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRow_pattern_factorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRow_pattern_factorContext) +} + +func (s *Row_pattern_concatenationContext) Row_pattern_concatenation() IRow_pattern_concatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRow_pattern_concatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRow_pattern_concatenationContext) +} + +func (s *Row_pattern_concatenationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Row_pattern_concatenationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Row_pattern_concatenationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterRow_pattern_concatenation(s) + } +} + +func (s *Row_pattern_concatenationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitRow_pattern_concatenation(s) + } +} + +func (s *Row_pattern_concatenationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitRow_pattern_concatenation(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Row_pattern_concatenation() (localctx IRow_pattern_concatenationContext) { + return p.row_pattern_concatenation(0) +} + +func (p *GoogleSQLParser) row_pattern_concatenation(_p int) (localctx IRow_pattern_concatenationContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewRow_pattern_concatenationContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IRow_pattern_concatenationContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 824 + p.EnterRecursionRule(localctx, 824, GoogleSQLParserRULE_row_pattern_concatenation, _p) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5091) + p.Row_pattern_factor() + } + + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(5097) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 642, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + localctx = NewRow_pattern_concatenationContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_row_pattern_concatenation) + p.SetState(5093) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(5094) + p.Row_pattern_factor() + } + + } + p.SetState(5099) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 642, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRow_pattern_factorContext is an interface to support dynamic dispatch. +type IRow_pattern_factorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + LR_BRACKET_SYMBOL() antlr.TerminalNode + Row_pattern_expr() IRow_pattern_exprContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsRow_pattern_factorContext differentiates from other interfaces. + IsRow_pattern_factorContext() +} + +type Row_pattern_factorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRow_pattern_factorContext() *Row_pattern_factorContext { + var p = new(Row_pattern_factorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_row_pattern_factor + return p +} + +func InitEmptyRow_pattern_factorContext(p *Row_pattern_factorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_row_pattern_factor +} + +func (*Row_pattern_factorContext) IsRow_pattern_factorContext() {} + +func NewRow_pattern_factorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Row_pattern_factorContext { + var p = new(Row_pattern_factorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_row_pattern_factor + + return p +} + +func (s *Row_pattern_factorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Row_pattern_factorContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Row_pattern_factorContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Row_pattern_factorContext) Row_pattern_expr() IRow_pattern_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRow_pattern_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRow_pattern_exprContext) +} + +func (s *Row_pattern_factorContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Row_pattern_factorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Row_pattern_factorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Row_pattern_factorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterRow_pattern_factor(s) + } +} + +func (s *Row_pattern_factorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitRow_pattern_factor(s) + } +} + +func (s *Row_pattern_factorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitRow_pattern_factor(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Row_pattern_factor() (localctx IRow_pattern_factorContext) { + localctx = NewRow_pattern_factorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 826, GoogleSQLParserRULE_row_pattern_factor) + p.SetState(5105) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5100) + p.Identifier() + } + + case GoogleSQLParserLR_BRACKET_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5101) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5102) + p.row_pattern_expr(0) + } + { + p.SetState(5103) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_list_prefix_with_as_aliasesContext is an interface to support dynamic dispatch. +type ISelect_list_prefix_with_as_aliasesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSelect_column_expr_with_as_alias() []ISelect_column_expr_with_as_aliasContext + Select_column_expr_with_as_alias(i int) ISelect_column_expr_with_as_aliasContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsSelect_list_prefix_with_as_aliasesContext differentiates from other interfaces. + IsSelect_list_prefix_with_as_aliasesContext() +} + +type Select_list_prefix_with_as_aliasesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_list_prefix_with_as_aliasesContext() *Select_list_prefix_with_as_aliasesContext { + var p = new(Select_list_prefix_with_as_aliasesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_select_list_prefix_with_as_aliases + return p +} + +func InitEmptySelect_list_prefix_with_as_aliasesContext(p *Select_list_prefix_with_as_aliasesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_select_list_prefix_with_as_aliases +} + +func (*Select_list_prefix_with_as_aliasesContext) IsSelect_list_prefix_with_as_aliasesContext() {} + +func NewSelect_list_prefix_with_as_aliasesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_list_prefix_with_as_aliasesContext { + var p = new(Select_list_prefix_with_as_aliasesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_select_list_prefix_with_as_aliases + + return p +} + +func (s *Select_list_prefix_with_as_aliasesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_list_prefix_with_as_aliasesContext) AllSelect_column_expr_with_as_alias() []ISelect_column_expr_with_as_aliasContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISelect_column_expr_with_as_aliasContext); ok { + len++ + } + } + + tst := make([]ISelect_column_expr_with_as_aliasContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISelect_column_expr_with_as_aliasContext); ok { + tst[i] = t.(ISelect_column_expr_with_as_aliasContext) + i++ + } + } + + return tst +} + +func (s *Select_list_prefix_with_as_aliasesContext) Select_column_expr_with_as_alias(i int) ISelect_column_expr_with_as_aliasContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_column_expr_with_as_aliasContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISelect_column_expr_with_as_aliasContext) +} + +func (s *Select_list_prefix_with_as_aliasesContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Select_list_prefix_with_as_aliasesContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Select_list_prefix_with_as_aliasesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_list_prefix_with_as_aliasesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_list_prefix_with_as_aliasesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSelect_list_prefix_with_as_aliases(s) + } +} + +func (s *Select_list_prefix_with_as_aliasesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSelect_list_prefix_with_as_aliases(s) + } +} + +func (s *Select_list_prefix_with_as_aliasesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSelect_list_prefix_with_as_aliases(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Select_list_prefix_with_as_aliases() (localctx ISelect_list_prefix_with_as_aliasesContext) { + localctx = NewSelect_list_prefix_with_as_aliasesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 828, GoogleSQLParserRULE_select_list_prefix_with_as_aliases) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5107) + p.Select_column_expr_with_as_alias() + } + p.SetState(5112) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(5108) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5109) + p.Select_column_expr_with_as_alias() + } + + p.SetState(5114) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_column_expr_with_as_aliasContext is an interface to support dynamic dispatch. +type ISelect_column_expr_with_as_aliasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + AS_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsSelect_column_expr_with_as_aliasContext differentiates from other interfaces. + IsSelect_column_expr_with_as_aliasContext() +} + +type Select_column_expr_with_as_aliasContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_column_expr_with_as_aliasContext() *Select_column_expr_with_as_aliasContext { + var p = new(Select_column_expr_with_as_aliasContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_select_column_expr_with_as_alias + return p +} + +func InitEmptySelect_column_expr_with_as_aliasContext(p *Select_column_expr_with_as_aliasContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_select_column_expr_with_as_alias +} + +func (*Select_column_expr_with_as_aliasContext) IsSelect_column_expr_with_as_aliasContext() {} + +func NewSelect_column_expr_with_as_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_column_expr_with_as_aliasContext { + var p = new(Select_column_expr_with_as_aliasContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_select_column_expr_with_as_alias + + return p +} + +func (s *Select_column_expr_with_as_aliasContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_column_expr_with_as_aliasContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Select_column_expr_with_as_aliasContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Select_column_expr_with_as_aliasContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Select_column_expr_with_as_aliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_column_expr_with_as_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_column_expr_with_as_aliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSelect_column_expr_with_as_alias(s) + } +} + +func (s *Select_column_expr_with_as_aliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSelect_column_expr_with_as_alias(s) + } +} + +func (s *Select_column_expr_with_as_aliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSelect_column_expr_with_as_alias(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Select_column_expr_with_as_alias() (localctx ISelect_column_expr_with_as_aliasContext) { + localctx = NewSelect_column_expr_with_as_aliasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 830, GoogleSQLParserRULE_select_column_expr_with_as_alias) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5115) + p.expression(0) + } + { + p.SetState(5116) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5117) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_subqueryContext is an interface to support dynamic dispatch. +type ITable_subqueryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Parenthesized_query() IParenthesized_queryContext + Opt_pivot_or_unpivot_clause_and_alias() IOpt_pivot_or_unpivot_clause_and_aliasContext + + // IsTable_subqueryContext differentiates from other interfaces. + IsTable_subqueryContext() +} + +type Table_subqueryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_subqueryContext() *Table_subqueryContext { + var p = new(Table_subqueryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_subquery + return p +} + +func InitEmptyTable_subqueryContext(p *Table_subqueryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_subquery +} + +func (*Table_subqueryContext) IsTable_subqueryContext() {} + +func NewTable_subqueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_subqueryContext { + var p = new(Table_subqueryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_table_subquery + + return p +} + +func (s *Table_subqueryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_subqueryContext) Parenthesized_query() IParenthesized_queryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesized_queryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParenthesized_queryContext) +} + +func (s *Table_subqueryContext) Opt_pivot_or_unpivot_clause_and_alias() IOpt_pivot_or_unpivot_clause_and_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_pivot_or_unpivot_clause_and_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_pivot_or_unpivot_clause_and_aliasContext) +} + +func (s *Table_subqueryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_subqueryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_subqueryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTable_subquery(s) + } +} + +func (s *Table_subqueryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTable_subquery(s) + } +} + +func (s *Table_subqueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTable_subquery(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Table_subquery() (localctx ITable_subqueryContext) { + localctx = NewTable_subqueryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 832, GoogleSQLParserRULE_table_subquery) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5119) + p.Parenthesized_query() + } + p.SetState(5121) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 645, p.GetParserRuleContext()) == 1 { + { + p.SetState(5120) + p.Opt_pivot_or_unpivot_clause_and_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJoinContext is an interface to support dynamic dispatch. +type IJoinContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_primary() ITable_primaryContext + AllJoin_item() []IJoin_itemContext + Join_item(i int) IJoin_itemContext + + // IsJoinContext differentiates from other interfaces. + IsJoinContext() +} + +type JoinContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJoinContext() *JoinContext { + var p = new(JoinContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_join + return p +} + +func InitEmptyJoinContext(p *JoinContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_join +} + +func (*JoinContext) IsJoinContext() {} + +func NewJoinContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JoinContext { + var p = new(JoinContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_join + + return p +} + +func (s *JoinContext) GetParser() antlr.Parser { return s.parser } + +func (s *JoinContext) Table_primary() ITable_primaryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_primaryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_primaryContext) +} + +func (s *JoinContext) AllJoin_item() []IJoin_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJoin_itemContext); ok { + len++ + } + } + + tst := make([]IJoin_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJoin_itemContext); ok { + tst[i] = t.(IJoin_itemContext) + i++ + } + } + + return tst +} + +func (s *JoinContext) Join_item(i int) IJoin_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJoin_itemContext) +} + +func (s *JoinContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *JoinContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *JoinContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterJoin(s) + } +} + +func (s *JoinContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitJoin(s) + } +} + +func (s *JoinContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitJoin(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Join() (localctx IJoinContext) { + localctx = NewJoinContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 834, GoogleSQLParserRULE_join) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5123) + p.table_primary(0) + } + p.SetState(5127) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ((int64((_la-61)) & ^0x3f) == 0 && ((int64(1)<<(_la-61))&1073825795) != 0) || ((int64((_la-310)) & ^0x3f) == 0 && ((int64(1)<<(_la-310))&266241) != 0) { + { + p.SetState(5124) + p.Join_item() + } + + p.SetState(5129) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJoin_itemContext is an interface to support dynamic dispatch. +type IJoin_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + JOIN_SYMBOL() antlr.TerminalNode + Table_primary() ITable_primaryContext + Opt_natural() IOpt_naturalContext + Join_type() IJoin_typeContext + Join_hint() IJoin_hintContext + Hint() IHintContext + On_or_using_clause_list() IOn_or_using_clause_listContext + + // IsJoin_itemContext differentiates from other interfaces. + IsJoin_itemContext() +} + +type Join_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJoin_itemContext() *Join_itemContext { + var p = new(Join_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_join_item + return p +} + +func InitEmptyJoin_itemContext(p *Join_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_join_item +} + +func (*Join_itemContext) IsJoin_itemContext() {} + +func NewJoin_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_itemContext { + var p = new(Join_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_join_item + + return p +} + +func (s *Join_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Join_itemContext) JOIN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserJOIN_SYMBOL, 0) +} + +func (s *Join_itemContext) Table_primary() ITable_primaryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_primaryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_primaryContext) +} + +func (s *Join_itemContext) Opt_natural() IOpt_naturalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_naturalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_naturalContext) +} + +func (s *Join_itemContext) Join_type() IJoin_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJoin_typeContext) +} + +func (s *Join_itemContext) Join_hint() IJoin_hintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_hintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJoin_hintContext) +} + +func (s *Join_itemContext) Hint() IHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Join_itemContext) On_or_using_clause_list() IOn_or_using_clause_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_or_using_clause_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_or_using_clause_listContext) +} + +func (s *Join_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Join_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Join_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterJoin_item(s) + } +} + +func (s *Join_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitJoin_item(s) + } +} + +func (s *Join_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitJoin_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Join_item() (localctx IJoin_itemContext) { + localctx = NewJoin_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 836, GoogleSQLParserRULE_join_item) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5131) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserNATURAL_SYMBOL { + { + p.SetState(5130) + p.Opt_natural() + } + + } + p.SetState(5134) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-61)) & ^0x3f) == 0 && ((int64(1)<<(_la-61))&1073825793) != 0 { + { + p.SetState(5133) + p.Join_type() + } + + } + p.SetState(5137) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserHASH_SYMBOL || _la == GoogleSQLParserLOOKUP_SYMBOL { + { + p.SetState(5136) + p.Join_hint() + } + + } + { + p.SetState(5139) + p.Match(GoogleSQLParserJOIN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5141) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(5140) + p.Hint() + } + + } + { + p.SetState(5143) + p.table_primary(0) + } + p.SetState(5145) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserON_SYMBOL || _la == GoogleSQLParserUSING_SYMBOL { + { + p.SetState(5144) + p.On_or_using_clause_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOn_or_using_clause_listContext is an interface to support dynamic dispatch. +type IOn_or_using_clause_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllOn_or_using_clause() []IOn_or_using_clauseContext + On_or_using_clause(i int) IOn_or_using_clauseContext + + // IsOn_or_using_clause_listContext differentiates from other interfaces. + IsOn_or_using_clause_listContext() +} + +type On_or_using_clause_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOn_or_using_clause_listContext() *On_or_using_clause_listContext { + var p = new(On_or_using_clause_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_on_or_using_clause_list + return p +} + +func InitEmptyOn_or_using_clause_listContext(p *On_or_using_clause_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_on_or_using_clause_list +} + +func (*On_or_using_clause_listContext) IsOn_or_using_clause_listContext() {} + +func NewOn_or_using_clause_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_or_using_clause_listContext { + var p = new(On_or_using_clause_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_on_or_using_clause_list + + return p +} + +func (s *On_or_using_clause_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_or_using_clause_listContext) AllOn_or_using_clause() []IOn_or_using_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOn_or_using_clauseContext); ok { + len++ + } + } + + tst := make([]IOn_or_using_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOn_or_using_clauseContext); ok { + tst[i] = t.(IOn_or_using_clauseContext) + i++ + } + } + + return tst +} + +func (s *On_or_using_clause_listContext) On_or_using_clause(i int) IOn_or_using_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_or_using_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOn_or_using_clauseContext) +} + +func (s *On_or_using_clause_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_or_using_clause_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_or_using_clause_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOn_or_using_clause_list(s) + } +} + +func (s *On_or_using_clause_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOn_or_using_clause_list(s) + } +} + +func (s *On_or_using_clause_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOn_or_using_clause_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) On_or_using_clause_list() (localctx IOn_or_using_clause_listContext) { + localctx = NewOn_or_using_clause_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 838, GoogleSQLParserRULE_on_or_using_clause_list) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5148) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(5147) + p.On_or_using_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(5150) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 652, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOn_or_using_clauseContext is an interface to support dynamic dispatch. +type IOn_or_using_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + On_clause() IOn_clauseContext + Using_clause() IUsing_clauseContext + + // IsOn_or_using_clauseContext differentiates from other interfaces. + IsOn_or_using_clauseContext() +} + +type On_or_using_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOn_or_using_clauseContext() *On_or_using_clauseContext { + var p = new(On_or_using_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_on_or_using_clause + return p +} + +func InitEmptyOn_or_using_clauseContext(p *On_or_using_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_on_or_using_clause +} + +func (*On_or_using_clauseContext) IsOn_or_using_clauseContext() {} + +func NewOn_or_using_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_or_using_clauseContext { + var p = new(On_or_using_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_on_or_using_clause + + return p +} + +func (s *On_or_using_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_or_using_clauseContext) On_clause() IOn_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_clauseContext) +} + +func (s *On_or_using_clauseContext) Using_clause() IUsing_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_clauseContext) +} + +func (s *On_or_using_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_or_using_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_or_using_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOn_or_using_clause(s) + } +} + +func (s *On_or_using_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOn_or_using_clause(s) + } +} + +func (s *On_or_using_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOn_or_using_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) On_or_using_clause() (localctx IOn_or_using_clauseContext) { + localctx = NewOn_or_using_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 840, GoogleSQLParserRULE_on_or_using_clause) + p.SetState(5154) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserON_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5152) + p.On_clause() + } + + case GoogleSQLParserUSING_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5153) + p.Using_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUsing_clauseContext is an interface to support dynamic dispatch. +type IUsing_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + AllDOT_SYMBOL() []antlr.TerminalNode + DOT_SYMBOL(i int) antlr.TerminalNode + + // IsUsing_clauseContext differentiates from other interfaces. + IsUsing_clauseContext() +} + +type Using_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUsing_clauseContext() *Using_clauseContext { + var p = new(Using_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_using_clause + return p +} + +func InitEmptyUsing_clauseContext(p *Using_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_using_clause +} + +func (*Using_clauseContext) IsUsing_clauseContext() {} + +func NewUsing_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Using_clauseContext { + var p = new(Using_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_using_clause + + return p +} + +func (s *Using_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Using_clauseContext) USING_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUSING_SYMBOL, 0) +} + +func (s *Using_clauseContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Using_clauseContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Using_clauseContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Using_clauseContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Using_clauseContext) AllDOT_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserDOT_SYMBOL) +} + +func (s *Using_clauseContext) DOT_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDOT_SYMBOL, i) +} + +func (s *Using_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Using_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Using_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterUsing_clause(s) + } +} + +func (s *Using_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitUsing_clause(s) + } +} + +func (s *Using_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitUsing_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Using_clause() (localctx IUsing_clauseContext) { + localctx = NewUsing_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 842, GoogleSQLParserRULE_using_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5156) + p.Match(GoogleSQLParserUSING_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5157) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5158) + p.Identifier() + } + p.SetState(5163) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserDOT_SYMBOL { + { + p.SetState(5159) + p.Match(GoogleSQLParserDOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5160) + p.Identifier() + } + + p.SetState(5165) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5166) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJoin_hintContext is an interface to support dynamic dispatch. +type IJoin_hintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HASH_SYMBOL() antlr.TerminalNode + LOOKUP_SYMBOL() antlr.TerminalNode + + // IsJoin_hintContext differentiates from other interfaces. + IsJoin_hintContext() +} + +type Join_hintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJoin_hintContext() *Join_hintContext { + var p = new(Join_hintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_join_hint + return p +} + +func InitEmptyJoin_hintContext(p *Join_hintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_join_hint +} + +func (*Join_hintContext) IsJoin_hintContext() {} + +func NewJoin_hintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_hintContext { + var p = new(Join_hintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_join_hint + + return p +} + +func (s *Join_hintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Join_hintContext) HASH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserHASH_SYMBOL, 0) +} + +func (s *Join_hintContext) LOOKUP_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLOOKUP_SYMBOL, 0) +} + +func (s *Join_hintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Join_hintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Join_hintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterJoin_hint(s) + } +} + +func (s *Join_hintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitJoin_hint(s) + } +} + +func (s *Join_hintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitJoin_hint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Join_hint() (localctx IJoin_hintContext) { + localctx = NewJoin_hintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 844, GoogleSQLParserRULE_join_hint) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5168) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserHASH_SYMBOL || _la == GoogleSQLParserLOOKUP_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_path_expressionContext is an interface to support dynamic dispatch. +type ITable_path_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_path_expression_base() ITable_path_expression_baseContext + Hint() IHintContext + Opt_pivot_or_unpivot_clause_and_alias() IOpt_pivot_or_unpivot_clause_and_aliasContext + Opt_with_offset_and_alias() IOpt_with_offset_and_aliasContext + Opt_at_system_time() IOpt_at_system_timeContext + + // IsTable_path_expressionContext differentiates from other interfaces. + IsTable_path_expressionContext() +} + +type Table_path_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_path_expressionContext() *Table_path_expressionContext { + var p = new(Table_path_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_path_expression + return p +} + +func InitEmptyTable_path_expressionContext(p *Table_path_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_path_expression +} + +func (*Table_path_expressionContext) IsTable_path_expressionContext() {} + +func NewTable_path_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_path_expressionContext { + var p = new(Table_path_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_table_path_expression + + return p +} + +func (s *Table_path_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_path_expressionContext) Table_path_expression_base() ITable_path_expression_baseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_path_expression_baseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_path_expression_baseContext) +} + +func (s *Table_path_expressionContext) Hint() IHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Table_path_expressionContext) Opt_pivot_or_unpivot_clause_and_alias() IOpt_pivot_or_unpivot_clause_and_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_pivot_or_unpivot_clause_and_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_pivot_or_unpivot_clause_and_aliasContext) +} + +func (s *Table_path_expressionContext) Opt_with_offset_and_alias() IOpt_with_offset_and_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_with_offset_and_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_with_offset_and_aliasContext) +} + +func (s *Table_path_expressionContext) Opt_at_system_time() IOpt_at_system_timeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_at_system_timeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_at_system_timeContext) +} + +func (s *Table_path_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_path_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_path_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTable_path_expression(s) + } +} + +func (s *Table_path_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTable_path_expression(s) + } +} + +func (s *Table_path_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTable_path_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Table_path_expression() (localctx ITable_path_expressionContext) { + localctx = NewTable_path_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 846, GoogleSQLParserRULE_table_path_expression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5170) + p.Table_path_expression_base() + } + p.SetState(5172) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 655, p.GetParserRuleContext()) == 1 { + { + p.SetState(5171) + p.Hint() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5175) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 656, p.GetParserRuleContext()) == 1 { + { + p.SetState(5174) + p.Opt_pivot_or_unpivot_clause_and_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5178) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 657, p.GetParserRuleContext()) == 1 { + { + p.SetState(5177) + p.Opt_with_offset_and_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5181) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 658, p.GetParserRuleContext()) == 1 { + { + p.SetState(5180) + p.Opt_at_system_time() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_at_system_timeContext is an interface to support dynamic dispatch. +type IOpt_at_system_timeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR_SYMBOL() antlr.TerminalNode + SYSTEM_SYMBOL() antlr.TerminalNode + TIME_SYMBOL() antlr.TerminalNode + AS_SYMBOL() antlr.TerminalNode + OF_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + SYSTEM_TIME_SYMBOL() antlr.TerminalNode + + // IsOpt_at_system_timeContext differentiates from other interfaces. + IsOpt_at_system_timeContext() +} + +type Opt_at_system_timeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_at_system_timeContext() *Opt_at_system_timeContext { + var p = new(Opt_at_system_timeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_at_system_time + return p +} + +func InitEmptyOpt_at_system_timeContext(p *Opt_at_system_timeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_at_system_time +} + +func (*Opt_at_system_timeContext) IsOpt_at_system_timeContext() {} + +func NewOpt_at_system_timeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_at_system_timeContext { + var p = new(Opt_at_system_timeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_at_system_time + + return p +} + +func (s *Opt_at_system_timeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_at_system_timeContext) FOR_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFOR_SYMBOL, 0) +} + +func (s *Opt_at_system_timeContext) SYSTEM_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSYSTEM_SYMBOL, 0) +} + +func (s *Opt_at_system_timeContext) TIME_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTIME_SYMBOL, 0) +} + +func (s *Opt_at_system_timeContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Opt_at_system_timeContext) OF_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOF_SYMBOL, 0) +} + +func (s *Opt_at_system_timeContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Opt_at_system_timeContext) SYSTEM_TIME_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSYSTEM_TIME_SYMBOL, 0) +} + +func (s *Opt_at_system_timeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_at_system_timeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_at_system_timeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_at_system_time(s) + } +} + +func (s *Opt_at_system_timeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_at_system_time(s) + } +} + +func (s *Opt_at_system_timeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_at_system_time(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_at_system_time() (localctx IOpt_at_system_timeContext) { + localctx = NewOpt_at_system_timeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 848, GoogleSQLParserRULE_opt_at_system_time) + p.SetState(5194) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 659, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5183) + p.Match(GoogleSQLParserFOR_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5184) + p.Match(GoogleSQLParserSYSTEM_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5185) + p.Match(GoogleSQLParserTIME_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5186) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5187) + p.Match(GoogleSQLParserOF_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5188) + p.expression(0) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5189) + p.Match(GoogleSQLParserFOR_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5190) + p.Match(GoogleSQLParserSYSTEM_TIME_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5191) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5192) + p.Match(GoogleSQLParserOF_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5193) + p.expression(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_with_offset_and_aliasContext is an interface to support dynamic dispatch. +type IOpt_with_offset_and_aliasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH_SYMBOL() antlr.TerminalNode + OFFSET_SYMBOL() antlr.TerminalNode + As_alias() IAs_aliasContext + + // IsOpt_with_offset_and_aliasContext differentiates from other interfaces. + IsOpt_with_offset_and_aliasContext() +} + +type Opt_with_offset_and_aliasContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_with_offset_and_aliasContext() *Opt_with_offset_and_aliasContext { + var p = new(Opt_with_offset_and_aliasContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_with_offset_and_alias + return p +} + +func InitEmptyOpt_with_offset_and_aliasContext(p *Opt_with_offset_and_aliasContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_with_offset_and_alias +} + +func (*Opt_with_offset_and_aliasContext) IsOpt_with_offset_and_aliasContext() {} + +func NewOpt_with_offset_and_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_with_offset_and_aliasContext { + var p = new(Opt_with_offset_and_aliasContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_with_offset_and_alias + + return p +} + +func (s *Opt_with_offset_and_aliasContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_with_offset_and_aliasContext) WITH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWITH_SYMBOL, 0) +} + +func (s *Opt_with_offset_and_aliasContext) OFFSET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOFFSET_SYMBOL, 0) +} + +func (s *Opt_with_offset_and_aliasContext) As_alias() IAs_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_aliasContext) +} + +func (s *Opt_with_offset_and_aliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_with_offset_and_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_with_offset_and_aliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_with_offset_and_alias(s) + } +} + +func (s *Opt_with_offset_and_aliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_with_offset_and_alias(s) + } +} + +func (s *Opt_with_offset_and_aliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_with_offset_and_alias(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_with_offset_and_alias() (localctx IOpt_with_offset_and_aliasContext) { + localctx = NewOpt_with_offset_and_aliasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 850, GoogleSQLParserRULE_opt_with_offset_and_alias) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5196) + p.Match(GoogleSQLParserWITH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5197) + p.Match(GoogleSQLParserOFFSET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5199) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 660, p.GetParserRuleContext()) == 1 { + { + p.SetState(5198) + p.As_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_pivot_or_unpivot_clause_and_aliasContext is an interface to support dynamic dispatch. +type IOpt_pivot_or_unpivot_clause_and_aliasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AS_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + Pivot_clause() IPivot_clauseContext + As_alias() IAs_aliasContext + Unpivot_clause() IUnpivot_clauseContext + Qualify_clause_nonreserved() IQualify_clause_nonreservedContext + + // IsOpt_pivot_or_unpivot_clause_and_aliasContext differentiates from other interfaces. + IsOpt_pivot_or_unpivot_clause_and_aliasContext() +} + +type Opt_pivot_or_unpivot_clause_and_aliasContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_pivot_or_unpivot_clause_and_aliasContext() *Opt_pivot_or_unpivot_clause_and_aliasContext { + var p = new(Opt_pivot_or_unpivot_clause_and_aliasContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_pivot_or_unpivot_clause_and_alias + return p +} + +func InitEmptyOpt_pivot_or_unpivot_clause_and_aliasContext(p *Opt_pivot_or_unpivot_clause_and_aliasContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_pivot_or_unpivot_clause_and_alias +} + +func (*Opt_pivot_or_unpivot_clause_and_aliasContext) IsOpt_pivot_or_unpivot_clause_and_aliasContext() { +} + +func NewOpt_pivot_or_unpivot_clause_and_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_pivot_or_unpivot_clause_and_aliasContext { + var p = new(Opt_pivot_or_unpivot_clause_and_aliasContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_pivot_or_unpivot_clause_and_alias + + return p +} + +func (s *Opt_pivot_or_unpivot_clause_and_aliasContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_pivot_or_unpivot_clause_and_aliasContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Opt_pivot_or_unpivot_clause_and_aliasContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Opt_pivot_or_unpivot_clause_and_aliasContext) Pivot_clause() IPivot_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPivot_clauseContext) +} + +func (s *Opt_pivot_or_unpivot_clause_and_aliasContext) As_alias() IAs_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_aliasContext) +} + +func (s *Opt_pivot_or_unpivot_clause_and_aliasContext) Unpivot_clause() IUnpivot_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnpivot_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnpivot_clauseContext) +} + +func (s *Opt_pivot_or_unpivot_clause_and_aliasContext) Qualify_clause_nonreserved() IQualify_clause_nonreservedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualify_clause_nonreservedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualify_clause_nonreservedContext) +} + +func (s *Opt_pivot_or_unpivot_clause_and_aliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_pivot_or_unpivot_clause_and_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_pivot_or_unpivot_clause_and_aliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_pivot_or_unpivot_clause_and_alias(s) + } +} + +func (s *Opt_pivot_or_unpivot_clause_and_aliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_pivot_or_unpivot_clause_and_alias(s) + } +} + +func (s *Opt_pivot_or_unpivot_clause_and_aliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_pivot_or_unpivot_clause_and_alias(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_pivot_or_unpivot_clause_and_alias() (localctx IOpt_pivot_or_unpivot_clause_and_aliasContext) { + localctx = NewOpt_pivot_or_unpivot_clause_and_aliasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 852, GoogleSQLParserRULE_opt_pivot_or_unpivot_clause_and_alias) + p.SetState(5246) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 667, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5201) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5202) + p.Identifier() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5203) + p.Identifier() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5204) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5205) + p.Identifier() + } + { + p.SetState(5206) + p.Pivot_clause() + } + p.SetState(5208) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 661, p.GetParserRuleContext()) == 1 { + { + p.SetState(5207) + p.As_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5210) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5211) + p.Identifier() + } + { + p.SetState(5212) + p.Unpivot_clause() + } + p.SetState(5214) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 662, p.GetParserRuleContext()) == 1 { + { + p.SetState(5213) + p.As_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5216) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5217) + p.Identifier() + } + { + p.SetState(5218) + p.Qualify_clause_nonreserved() + } + p.NotifyErrorListeners("QUALIFY clause must be used in conjunction with WHERE or GROUP BY or HAVING clause", nil, nil) + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5221) + p.Identifier() + } + { + p.SetState(5222) + p.Pivot_clause() + } + p.SetState(5224) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 663, p.GetParserRuleContext()) == 1 { + { + p.SetState(5223) + p.As_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(5226) + p.Identifier() + } + { + p.SetState(5227) + p.Unpivot_clause() + } + p.SetState(5229) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 664, p.GetParserRuleContext()) == 1 { + { + p.SetState(5228) + p.As_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(5231) + p.Identifier() + } + { + p.SetState(5232) + p.Qualify_clause_nonreserved() + } + p.NotifyErrorListeners("QUALIFY clause must be used in conjunction with WHERE or GROUP BY or HAVING clause", nil, nil) + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(5235) + p.Pivot_clause() + } + p.SetState(5237) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 665, p.GetParserRuleContext()) == 1 { + { + p.SetState(5236) + p.As_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(5239) + p.Unpivot_clause() + } + p.SetState(5241) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 666, p.GetParserRuleContext()) == 1 { + { + p.SetState(5240) + p.As_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(5243) + p.Qualify_clause_nonreserved() + } + p.NotifyErrorListeners("QUALIFY clause must be used in conjunction with WHERE or GROUP BY or HAVING clause", nil, nil) + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_path_expression_baseContext is an interface to support dynamic dispatch. +type ITable_path_expression_baseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Unnest_expression() IUnnest_expressionContext + Maybe_slashed_or_dashed_path_expression() IMaybe_slashed_or_dashed_path_expressionContext + Path_expression() IPath_expressionContext + LS_BRACKET_SYMBOL() antlr.TerminalNode + DOT_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsTable_path_expression_baseContext differentiates from other interfaces. + IsTable_path_expression_baseContext() +} + +type Table_path_expression_baseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_path_expression_baseContext() *Table_path_expression_baseContext { + var p = new(Table_path_expression_baseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_path_expression_base + return p +} + +func InitEmptyTable_path_expression_baseContext(p *Table_path_expression_baseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_path_expression_base +} + +func (*Table_path_expression_baseContext) IsTable_path_expression_baseContext() {} + +func NewTable_path_expression_baseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_path_expression_baseContext { + var p = new(Table_path_expression_baseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_table_path_expression_base + + return p +} + +func (s *Table_path_expression_baseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_path_expression_baseContext) Unnest_expression() IUnnest_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnnest_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnnest_expressionContext) +} + +func (s *Table_path_expression_baseContext) Maybe_slashed_or_dashed_path_expression() IMaybe_slashed_or_dashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_slashed_or_dashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_slashed_or_dashed_path_expressionContext) +} + +func (s *Table_path_expression_baseContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Table_path_expression_baseContext) LS_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLS_BRACKET_SYMBOL, 0) +} + +func (s *Table_path_expression_baseContext) DOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDOT_SYMBOL, 0) +} + +func (s *Table_path_expression_baseContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Table_path_expression_baseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_path_expression_baseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_path_expression_baseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTable_path_expression_base(s) + } +} + +func (s *Table_path_expression_baseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTable_path_expression_base(s) + } +} + +func (s *Table_path_expression_baseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTable_path_expression_base(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Table_path_expression_base() (localctx ITable_path_expression_baseContext) { + localctx = NewTable_path_expression_baseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 854, GoogleSQLParserRULE_table_path_expression_base) + p.SetState(5268) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 668, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5248) + p.Unnest_expression() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5249) + p.Maybe_slashed_or_dashed_path_expression() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5250) + p.Path_expression() + } + { + p.SetState(5251) + p.Match(GoogleSQLParserLS_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.NotifyErrorListeners("Syntax error: Array element access is not allowed in the FROM clause without UNNEST; Use UNNEST()", nil, nil) + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5254) + p.Path_expression() + } + { + p.SetState(5255) + p.Match(GoogleSQLParserDOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5256) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.NotifyErrorListeners("Syntax error: Generalized field access is not allowed in the FROM clause without UNNEST; Use UNNEST()", nil, nil) + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5259) + p.Unnest_expression() + } + { + p.SetState(5260) + p.Match(GoogleSQLParserLS_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.NotifyErrorListeners("Syntax error: Array element access is not allowed in the FROM clause without UNNEST; Use UNNEST()", nil, nil) + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5263) + p.Unnest_expression() + } + { + p.SetState(5264) + p.Match(GoogleSQLParserDOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5265) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.NotifyErrorListeners("Syntax error: Generalized field access is not allowed in the FROM clause without UNNEST; Use UNNEST()", nil, nil) + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMaybe_slashed_or_dashed_path_expressionContext is an interface to support dynamic dispatch. +type IMaybe_slashed_or_dashed_path_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext + Slashed_path_expression() ISlashed_path_expressionContext + + // IsMaybe_slashed_or_dashed_path_expressionContext differentiates from other interfaces. + IsMaybe_slashed_or_dashed_path_expressionContext() +} + +type Maybe_slashed_or_dashed_path_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMaybe_slashed_or_dashed_path_expressionContext() *Maybe_slashed_or_dashed_path_expressionContext { + var p = new(Maybe_slashed_or_dashed_path_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_maybe_slashed_or_dashed_path_expression + return p +} + +func InitEmptyMaybe_slashed_or_dashed_path_expressionContext(p *Maybe_slashed_or_dashed_path_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_maybe_slashed_or_dashed_path_expression +} + +func (*Maybe_slashed_or_dashed_path_expressionContext) IsMaybe_slashed_or_dashed_path_expressionContext() { +} + +func NewMaybe_slashed_or_dashed_path_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Maybe_slashed_or_dashed_path_expressionContext { + var p = new(Maybe_slashed_or_dashed_path_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_maybe_slashed_or_dashed_path_expression + + return p +} + +func (s *Maybe_slashed_or_dashed_path_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Maybe_slashed_or_dashed_path_expressionContext) Maybe_dashed_path_expression() IMaybe_dashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaybe_dashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaybe_dashed_path_expressionContext) +} + +func (s *Maybe_slashed_or_dashed_path_expressionContext) Slashed_path_expression() ISlashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISlashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISlashed_path_expressionContext) +} + +func (s *Maybe_slashed_or_dashed_path_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Maybe_slashed_or_dashed_path_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Maybe_slashed_or_dashed_path_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterMaybe_slashed_or_dashed_path_expression(s) + } +} + +func (s *Maybe_slashed_or_dashed_path_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitMaybe_slashed_or_dashed_path_expression(s) + } +} + +func (s *Maybe_slashed_or_dashed_path_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitMaybe_slashed_or_dashed_path_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Maybe_slashed_or_dashed_path_expression() (localctx IMaybe_slashed_or_dashed_path_expressionContext) { + localctx = NewMaybe_slashed_or_dashed_path_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 856, GoogleSQLParserRULE_maybe_slashed_or_dashed_path_expression) + p.SetState(5272) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5270) + p.Maybe_dashed_path_expression() + } + + case GoogleSQLParserSLASH_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5271) + p.Slashed_path_expression() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMaybe_dashed_path_expressionContext is an interface to support dynamic dispatch. +type IMaybe_dashed_path_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Path_expression() IPath_expressionContext + Dashed_path_expression() IDashed_path_expressionContext + + // IsMaybe_dashed_path_expressionContext differentiates from other interfaces. + IsMaybe_dashed_path_expressionContext() +} + +type Maybe_dashed_path_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMaybe_dashed_path_expressionContext() *Maybe_dashed_path_expressionContext { + var p = new(Maybe_dashed_path_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_maybe_dashed_path_expression + return p +} + +func InitEmptyMaybe_dashed_path_expressionContext(p *Maybe_dashed_path_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_maybe_dashed_path_expression +} + +func (*Maybe_dashed_path_expressionContext) IsMaybe_dashed_path_expressionContext() {} + +func NewMaybe_dashed_path_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Maybe_dashed_path_expressionContext { + var p = new(Maybe_dashed_path_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_maybe_dashed_path_expression + + return p +} + +func (s *Maybe_dashed_path_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Maybe_dashed_path_expressionContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Maybe_dashed_path_expressionContext) Dashed_path_expression() IDashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDashed_path_expressionContext) +} + +func (s *Maybe_dashed_path_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Maybe_dashed_path_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Maybe_dashed_path_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterMaybe_dashed_path_expression(s) + } +} + +func (s *Maybe_dashed_path_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitMaybe_dashed_path_expression(s) + } +} + +func (s *Maybe_dashed_path_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitMaybe_dashed_path_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Maybe_dashed_path_expression() (localctx IMaybe_dashed_path_expressionContext) { + localctx = NewMaybe_dashed_path_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 858, GoogleSQLParserRULE_maybe_dashed_path_expression) + p.SetState(5276) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 670, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5274) + p.Path_expression() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5275) + p.dashed_path_expression(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDashed_path_expressionContext is an interface to support dynamic dispatch. +type IDashed_path_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Dashed_identifier() IDashed_identifierContext + Dashed_path_expression() IDashed_path_expressionContext + DOT_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsDashed_path_expressionContext differentiates from other interfaces. + IsDashed_path_expressionContext() +} + +type Dashed_path_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDashed_path_expressionContext() *Dashed_path_expressionContext { + var p = new(Dashed_path_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_dashed_path_expression + return p +} + +func InitEmptyDashed_path_expressionContext(p *Dashed_path_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_dashed_path_expression +} + +func (*Dashed_path_expressionContext) IsDashed_path_expressionContext() {} + +func NewDashed_path_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dashed_path_expressionContext { + var p = new(Dashed_path_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_dashed_path_expression + + return p +} + +func (s *Dashed_path_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dashed_path_expressionContext) Dashed_identifier() IDashed_identifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDashed_identifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDashed_identifierContext) +} + +func (s *Dashed_path_expressionContext) Dashed_path_expression() IDashed_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDashed_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDashed_path_expressionContext) +} + +func (s *Dashed_path_expressionContext) DOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDOT_SYMBOL, 0) +} + +func (s *Dashed_path_expressionContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Dashed_path_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dashed_path_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dashed_path_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterDashed_path_expression(s) + } +} + +func (s *Dashed_path_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitDashed_path_expression(s) + } +} + +func (s *Dashed_path_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitDashed_path_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Dashed_path_expression() (localctx IDashed_path_expressionContext) { + return p.dashed_path_expression(0) +} + +func (p *GoogleSQLParser) dashed_path_expression(_p int) (localctx IDashed_path_expressionContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewDashed_path_expressionContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IDashed_path_expressionContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 860 + p.EnterRecursionRule(localctx, 860, GoogleSQLParserRULE_dashed_path_expression, _p) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5279) + p.dashed_identifier(0) + } + + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(5286) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 671, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + localctx = NewDashed_path_expressionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_dashed_path_expression) + p.SetState(5281) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(5282) + p.Match(GoogleSQLParserDOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5283) + p.Identifier() + } + + } + p.SetState(5288) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 671, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDashed_identifierContext is an interface to support dynamic dispatch. +type IDashed_identifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + MINUS_OPERATOR() antlr.TerminalNode + INTEGER_LITERAL() antlr.TerminalNode + Floating_point_literal() IFloating_point_literalContext + AllDashed_identifier() []IDashed_identifierContext + Dashed_identifier(i int) IDashed_identifierContext + + // IsDashed_identifierContext differentiates from other interfaces. + IsDashed_identifierContext() +} + +type Dashed_identifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDashed_identifierContext() *Dashed_identifierContext { + var p = new(Dashed_identifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_dashed_identifier + return p +} + +func InitEmptyDashed_identifierContext(p *Dashed_identifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_dashed_identifier +} + +func (*Dashed_identifierContext) IsDashed_identifierContext() {} + +func NewDashed_identifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dashed_identifierContext { + var p = new(Dashed_identifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_dashed_identifier + + return p +} + +func (s *Dashed_identifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dashed_identifierContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Dashed_identifierContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Dashed_identifierContext) MINUS_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMINUS_OPERATOR, 0) +} + +func (s *Dashed_identifierContext) INTEGER_LITERAL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINTEGER_LITERAL, 0) +} + +func (s *Dashed_identifierContext) Floating_point_literal() IFloating_point_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFloating_point_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFloating_point_literalContext) +} + +func (s *Dashed_identifierContext) AllDashed_identifier() []IDashed_identifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDashed_identifierContext); ok { + len++ + } + } + + tst := make([]IDashed_identifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDashed_identifierContext); ok { + tst[i] = t.(IDashed_identifierContext) + i++ + } + } + + return tst +} + +func (s *Dashed_identifierContext) Dashed_identifier(i int) IDashed_identifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDashed_identifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDashed_identifierContext) +} + +func (s *Dashed_identifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dashed_identifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dashed_identifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterDashed_identifier(s) + } +} + +func (s *Dashed_identifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitDashed_identifier(s) + } +} + +func (s *Dashed_identifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitDashed_identifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Dashed_identifier() (localctx IDashed_identifierContext) { + return p.dashed_identifier(0) +} + +func (p *GoogleSQLParser) dashed_identifier(_p int) (localctx IDashed_identifierContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewDashed_identifierContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IDashed_identifierContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 862 + p.EnterRecursionRule(localctx, 862, GoogleSQLParserRULE_dashed_identifier, _p) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5303) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 672, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5290) + p.Identifier() + } + { + p.SetState(5291) + p.Match(GoogleSQLParserMINUS_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5292) + p.Identifier() + } + + case 2: + { + p.SetState(5294) + p.Identifier() + } + { + p.SetState(5295) + p.Match(GoogleSQLParserMINUS_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5296) + p.Match(GoogleSQLParserINTEGER_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(5298) + p.Identifier() + } + { + p.SetState(5299) + p.Match(GoogleSQLParserMINUS_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5300) + p.Floating_point_literal() + } + { + p.SetState(5301) + p.Identifier() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(5318) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 674, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + p.SetState(5316) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 673, p.GetParserRuleContext()) { + case 1: + localctx = NewDashed_identifierContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_dashed_identifier) + p.SetState(5305) + + if !(p.Precpred(p.GetParserRuleContext(), 5)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", "")) + goto errorExit + } + { + p.SetState(5306) + p.Match(GoogleSQLParserMINUS_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5307) + p.dashed_identifier(6) + } + + case 2: + localctx = NewDashed_identifierContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_dashed_identifier) + p.SetState(5308) + + if !(p.Precpred(p.GetParserRuleContext(), 3)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", "")) + goto errorExit + } + { + p.SetState(5309) + p.Match(GoogleSQLParserMINUS_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5310) + p.Match(GoogleSQLParserINTEGER_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + localctx = NewDashed_identifierContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_dashed_identifier) + p.SetState(5311) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(5312) + p.Match(GoogleSQLParserMINUS_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5313) + p.Floating_point_literal() + } + { + p.SetState(5314) + p.Identifier() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(5320) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 674, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISlashed_identifierContext is an interface to support dynamic dispatch. +type ISlashed_identifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SLASH_SYMBOL() antlr.TerminalNode + Identifier_or_integer() IIdentifier_or_integerContext + Slashed_identifier() ISlashed_identifierContext + AllSlashed_identifier_separator() []ISlashed_identifier_separatorContext + Slashed_identifier_separator(i int) ISlashed_identifier_separatorContext + Floating_point_literal() IFloating_point_literalContext + + // IsSlashed_identifierContext differentiates from other interfaces. + IsSlashed_identifierContext() +} + +type Slashed_identifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySlashed_identifierContext() *Slashed_identifierContext { + var p = new(Slashed_identifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_slashed_identifier + return p +} + +func InitEmptySlashed_identifierContext(p *Slashed_identifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_slashed_identifier +} + +func (*Slashed_identifierContext) IsSlashed_identifierContext() {} + +func NewSlashed_identifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Slashed_identifierContext { + var p = new(Slashed_identifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_slashed_identifier + + return p +} + +func (s *Slashed_identifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *Slashed_identifierContext) SLASH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSLASH_SYMBOL, 0) +} + +func (s *Slashed_identifierContext) Identifier_or_integer() IIdentifier_or_integerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifier_or_integerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifier_or_integerContext) +} + +func (s *Slashed_identifierContext) Slashed_identifier() ISlashed_identifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISlashed_identifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISlashed_identifierContext) +} + +func (s *Slashed_identifierContext) AllSlashed_identifier_separator() []ISlashed_identifier_separatorContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISlashed_identifier_separatorContext); ok { + len++ + } + } + + tst := make([]ISlashed_identifier_separatorContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISlashed_identifier_separatorContext); ok { + tst[i] = t.(ISlashed_identifier_separatorContext) + i++ + } + } + + return tst +} + +func (s *Slashed_identifierContext) Slashed_identifier_separator(i int) ISlashed_identifier_separatorContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISlashed_identifier_separatorContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISlashed_identifier_separatorContext) +} + +func (s *Slashed_identifierContext) Floating_point_literal() IFloating_point_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFloating_point_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFloating_point_literalContext) +} + +func (s *Slashed_identifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Slashed_identifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Slashed_identifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSlashed_identifier(s) + } +} + +func (s *Slashed_identifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSlashed_identifier(s) + } +} + +func (s *Slashed_identifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSlashed_identifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Slashed_identifier() (localctx ISlashed_identifierContext) { + return p.slashed_identifier(0) +} + +func (p *GoogleSQLParser) slashed_identifier(_p int) (localctx ISlashed_identifierContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewSlashed_identifierContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx ISlashed_identifierContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 864 + p.EnterRecursionRule(localctx, 864, GoogleSQLParserRULE_slashed_identifier, _p) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5322) + p.Match(GoogleSQLParserSLASH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5323) + p.Identifier_or_integer() + } + + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(5337) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 676, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + p.SetState(5335) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 675, p.GetParserRuleContext()) { + case 1: + localctx = NewSlashed_identifierContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_slashed_identifier) + p.SetState(5325) + + if !(p.Precpred(p.GetParserRuleContext(), 2)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) + goto errorExit + } + { + p.SetState(5326) + p.Slashed_identifier_separator() + } + { + p.SetState(5327) + p.Identifier_or_integer() + } + + case 2: + localctx = NewSlashed_identifierContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_slashed_identifier) + p.SetState(5329) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(5330) + p.Slashed_identifier_separator() + } + { + p.SetState(5331) + p.Floating_point_literal() + } + { + p.SetState(5332) + p.Slashed_identifier_separator() + } + { + p.SetState(5333) + p.Identifier_or_integer() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(5339) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 676, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentifier_or_integerContext is an interface to support dynamic dispatch. +type IIdentifier_or_integerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + INTEGER_LITERAL() antlr.TerminalNode + + // IsIdentifier_or_integerContext differentiates from other interfaces. + IsIdentifier_or_integerContext() +} + +type Identifier_or_integerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentifier_or_integerContext() *Identifier_or_integerContext { + var p = new(Identifier_or_integerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_identifier_or_integer + return p +} + +func InitEmptyIdentifier_or_integerContext(p *Identifier_or_integerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_identifier_or_integer +} + +func (*Identifier_or_integerContext) IsIdentifier_or_integerContext() {} + +func NewIdentifier_or_integerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Identifier_or_integerContext { + var p = new(Identifier_or_integerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_identifier_or_integer + + return p +} + +func (s *Identifier_or_integerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Identifier_or_integerContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Identifier_or_integerContext) INTEGER_LITERAL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINTEGER_LITERAL, 0) +} + +func (s *Identifier_or_integerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Identifier_or_integerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Identifier_or_integerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterIdentifier_or_integer(s) + } +} + +func (s *Identifier_or_integerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitIdentifier_or_integer(s) + } +} + +func (s *Identifier_or_integerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitIdentifier_or_integer(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Identifier_or_integer() (localctx IIdentifier_or_integerContext) { + localctx = NewIdentifier_or_integerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 866, GoogleSQLParserRULE_identifier_or_integer) + p.SetState(5342) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5340) + p.Identifier() + } + + case GoogleSQLParserINTEGER_LITERAL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5341) + p.Match(GoogleSQLParserINTEGER_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISlashed_identifier_separatorContext is an interface to support dynamic dispatch. +type ISlashed_identifier_separatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MINUS_OPERATOR() antlr.TerminalNode + SLASH_SYMBOL() antlr.TerminalNode + COLON_SYMBOL() antlr.TerminalNode + + // IsSlashed_identifier_separatorContext differentiates from other interfaces. + IsSlashed_identifier_separatorContext() +} + +type Slashed_identifier_separatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySlashed_identifier_separatorContext() *Slashed_identifier_separatorContext { + var p = new(Slashed_identifier_separatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_slashed_identifier_separator + return p +} + +func InitEmptySlashed_identifier_separatorContext(p *Slashed_identifier_separatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_slashed_identifier_separator +} + +func (*Slashed_identifier_separatorContext) IsSlashed_identifier_separatorContext() {} + +func NewSlashed_identifier_separatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Slashed_identifier_separatorContext { + var p = new(Slashed_identifier_separatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_slashed_identifier_separator + + return p +} + +func (s *Slashed_identifier_separatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Slashed_identifier_separatorContext) MINUS_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMINUS_OPERATOR, 0) +} + +func (s *Slashed_identifier_separatorContext) SLASH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSLASH_SYMBOL, 0) +} + +func (s *Slashed_identifier_separatorContext) COLON_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOLON_SYMBOL, 0) +} + +func (s *Slashed_identifier_separatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Slashed_identifier_separatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Slashed_identifier_separatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSlashed_identifier_separator(s) + } +} + +func (s *Slashed_identifier_separatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSlashed_identifier_separator(s) + } +} + +func (s *Slashed_identifier_separatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSlashed_identifier_separator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Slashed_identifier_separator() (localctx ISlashed_identifier_separatorContext) { + localctx = NewSlashed_identifier_separatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 868, GoogleSQLParserRULE_slashed_identifier_separator) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5344) + p.Match(GoogleSQLParserMINUS_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5345) + p.Match(GoogleSQLParserSLASH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5346) + p.Match(GoogleSQLParserCOLON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISlashed_path_expressionContext is an interface to support dynamic dispatch. +type ISlashed_path_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Slashed_identifier() ISlashed_identifierContext + Slashed_identifier_separator() ISlashed_identifier_separatorContext + Floating_point_literal() IFloating_point_literalContext + Identifier() IIdentifierContext + + // IsSlashed_path_expressionContext differentiates from other interfaces. + IsSlashed_path_expressionContext() +} + +type Slashed_path_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySlashed_path_expressionContext() *Slashed_path_expressionContext { + var p = new(Slashed_path_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_slashed_path_expression + return p +} + +func InitEmptySlashed_path_expressionContext(p *Slashed_path_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_slashed_path_expression +} + +func (*Slashed_path_expressionContext) IsSlashed_path_expressionContext() {} + +func NewSlashed_path_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Slashed_path_expressionContext { + var p = new(Slashed_path_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_slashed_path_expression + + return p +} + +func (s *Slashed_path_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Slashed_path_expressionContext) Slashed_identifier() ISlashed_identifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISlashed_identifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISlashed_identifierContext) +} + +func (s *Slashed_path_expressionContext) Slashed_identifier_separator() ISlashed_identifier_separatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISlashed_identifier_separatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISlashed_identifier_separatorContext) +} + +func (s *Slashed_path_expressionContext) Floating_point_literal() IFloating_point_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFloating_point_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFloating_point_literalContext) +} + +func (s *Slashed_path_expressionContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Slashed_path_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Slashed_path_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Slashed_path_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSlashed_path_expression(s) + } +} + +func (s *Slashed_path_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSlashed_path_expression(s) + } +} + +func (s *Slashed_path_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSlashed_path_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Slashed_path_expression() (localctx ISlashed_path_expressionContext) { + localctx = NewSlashed_path_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 870, GoogleSQLParserRULE_slashed_path_expression) + p.SetState(5354) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 678, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5348) + p.slashed_identifier(0) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5349) + p.slashed_identifier(0) + } + { + p.SetState(5350) + p.Slashed_identifier_separator() + } + { + p.SetState(5351) + p.Floating_point_literal() + } + { + p.SetState(5352) + p.Identifier() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnnest_expressionContext is an interface to support dynamic dispatch. +type IUnnest_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Unnest_expression_prefix() IUnnest_expression_prefixContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + Opt_array_zip_mode() IOpt_array_zip_modeContext + UNNEST_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + SELECT_SYMBOL() antlr.TerminalNode + + // IsUnnest_expressionContext differentiates from other interfaces. + IsUnnest_expressionContext() +} + +type Unnest_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnnest_expressionContext() *Unnest_expressionContext { + var p = new(Unnest_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unnest_expression + return p +} + +func InitEmptyUnnest_expressionContext(p *Unnest_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unnest_expression +} + +func (*Unnest_expressionContext) IsUnnest_expressionContext() {} + +func NewUnnest_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unnest_expressionContext { + var p = new(Unnest_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_unnest_expression + + return p +} + +func (s *Unnest_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unnest_expressionContext) Unnest_expression_prefix() IUnnest_expression_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnnest_expression_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnnest_expression_prefixContext) +} + +func (s *Unnest_expressionContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Unnest_expressionContext) Opt_array_zip_mode() IOpt_array_zip_modeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_array_zip_modeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_array_zip_modeContext) +} + +func (s *Unnest_expressionContext) UNNEST_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUNNEST_SYMBOL, 0) +} + +func (s *Unnest_expressionContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Unnest_expressionContext) SELECT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSELECT_SYMBOL, 0) +} + +func (s *Unnest_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unnest_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unnest_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterUnnest_expression(s) + } +} + +func (s *Unnest_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitUnnest_expression(s) + } +} + +func (s *Unnest_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitUnnest_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Unnest_expression() (localctx IUnnest_expressionContext) { + localctx = NewUnnest_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 872, GoogleSQLParserRULE_unnest_expression) + var _la int + + p.SetState(5366) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 680, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5356) + p.Unnest_expression_prefix() + } + p.SetState(5358) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(5357) + p.Opt_array_zip_mode() + } + + } + { + p.SetState(5360) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5362) + p.Match(GoogleSQLParserUNNEST_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5363) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5364) + p.Match(GoogleSQLParserSELECT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.NotifyErrorListeners("The argument to UNNEST is an expression, not a query; to use a query as an expression, the query must be wrapped with additional parentheses to make it a scalar subquery expression", nil, nil) + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnnest_expression_prefixContext is an interface to support dynamic dispatch. +type IUnnest_expression_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNNEST_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + AllExpression_with_opt_alias() []IExpression_with_opt_aliasContext + Expression_with_opt_alias(i int) IExpression_with_opt_aliasContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsUnnest_expression_prefixContext differentiates from other interfaces. + IsUnnest_expression_prefixContext() +} + +type Unnest_expression_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnnest_expression_prefixContext() *Unnest_expression_prefixContext { + var p = new(Unnest_expression_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unnest_expression_prefix + return p +} + +func InitEmptyUnnest_expression_prefixContext(p *Unnest_expression_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unnest_expression_prefix +} + +func (*Unnest_expression_prefixContext) IsUnnest_expression_prefixContext() {} + +func NewUnnest_expression_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unnest_expression_prefixContext { + var p = new(Unnest_expression_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_unnest_expression_prefix + + return p +} + +func (s *Unnest_expression_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unnest_expression_prefixContext) UNNEST_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUNNEST_SYMBOL, 0) +} + +func (s *Unnest_expression_prefixContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Unnest_expression_prefixContext) AllExpression_with_opt_alias() []IExpression_with_opt_aliasContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpression_with_opt_aliasContext); ok { + len++ + } + } + + tst := make([]IExpression_with_opt_aliasContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpression_with_opt_aliasContext); ok { + tst[i] = t.(IExpression_with_opt_aliasContext) + i++ + } + } + + return tst +} + +func (s *Unnest_expression_prefixContext) Expression_with_opt_alias(i int) IExpression_with_opt_aliasContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_with_opt_aliasContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpression_with_opt_aliasContext) +} + +func (s *Unnest_expression_prefixContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Unnest_expression_prefixContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Unnest_expression_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unnest_expression_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unnest_expression_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterUnnest_expression_prefix(s) + } +} + +func (s *Unnest_expression_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitUnnest_expression_prefix(s) + } +} + +func (s *Unnest_expression_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitUnnest_expression_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Unnest_expression_prefix() (localctx IUnnest_expression_prefixContext) { + localctx = NewUnnest_expression_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 874, GoogleSQLParserRULE_unnest_expression_prefix) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5368) + p.Match(GoogleSQLParserUNNEST_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5369) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5370) + p.Expression_with_opt_alias() + } + p.SetState(5375) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 681, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5371) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5372) + p.Expression_with_opt_alias() + } + + } + p.SetState(5377) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 681, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_array_zip_modeContext is an interface to support dynamic dispatch. +type IOpt_array_zip_modeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMA_SYMBOL() antlr.TerminalNode + Named_argument() INamed_argumentContext + + // IsOpt_array_zip_modeContext differentiates from other interfaces. + IsOpt_array_zip_modeContext() +} + +type Opt_array_zip_modeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_array_zip_modeContext() *Opt_array_zip_modeContext { + var p = new(Opt_array_zip_modeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_array_zip_mode + return p +} + +func InitEmptyOpt_array_zip_modeContext(p *Opt_array_zip_modeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_array_zip_mode +} + +func (*Opt_array_zip_modeContext) IsOpt_array_zip_modeContext() {} + +func NewOpt_array_zip_modeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_array_zip_modeContext { + var p = new(Opt_array_zip_modeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_array_zip_mode + + return p +} + +func (s *Opt_array_zip_modeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_array_zip_modeContext) COMMA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, 0) +} + +func (s *Opt_array_zip_modeContext) Named_argument() INamed_argumentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INamed_argumentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INamed_argumentContext) +} + +func (s *Opt_array_zip_modeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_array_zip_modeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_array_zip_modeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_array_zip_mode(s) + } +} + +func (s *Opt_array_zip_modeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_array_zip_mode(s) + } +} + +func (s *Opt_array_zip_modeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_array_zip_mode(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_array_zip_mode() (localctx IOpt_array_zip_modeContext) { + localctx = NewOpt_array_zip_modeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 876, GoogleSQLParserRULE_opt_array_zip_mode) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5378) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5379) + p.Named_argument() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpression_with_opt_aliasContext is an interface to support dynamic dispatch. +type IExpression_with_opt_aliasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + Opt_as_alias_with_required_as() IOpt_as_alias_with_required_asContext + + // IsExpression_with_opt_aliasContext differentiates from other interfaces. + IsExpression_with_opt_aliasContext() +} + +type Expression_with_opt_aliasContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpression_with_opt_aliasContext() *Expression_with_opt_aliasContext { + var p = new(Expression_with_opt_aliasContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_expression_with_opt_alias + return p +} + +func InitEmptyExpression_with_opt_aliasContext(p *Expression_with_opt_aliasContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_expression_with_opt_alias +} + +func (*Expression_with_opt_aliasContext) IsExpression_with_opt_aliasContext() {} + +func NewExpression_with_opt_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expression_with_opt_aliasContext { + var p = new(Expression_with_opt_aliasContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_expression_with_opt_alias + + return p +} + +func (s *Expression_with_opt_aliasContext) GetParser() antlr.Parser { return s.parser } + +func (s *Expression_with_opt_aliasContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Expression_with_opt_aliasContext) Opt_as_alias_with_required_as() IOpt_as_alias_with_required_asContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_as_alias_with_required_asContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_as_alias_with_required_asContext) +} + +func (s *Expression_with_opt_aliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Expression_with_opt_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Expression_with_opt_aliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterExpression_with_opt_alias(s) + } +} + +func (s *Expression_with_opt_aliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitExpression_with_opt_alias(s) + } +} + +func (s *Expression_with_opt_aliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitExpression_with_opt_alias(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Expression_with_opt_alias() (localctx IExpression_with_opt_aliasContext) { + localctx = NewExpression_with_opt_aliasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 878, GoogleSQLParserRULE_expression_with_opt_alias) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5381) + p.expression(0) + } + p.SetState(5383) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(5382) + p.Opt_as_alias_with_required_as() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITvf_prefixContext is an interface to support dynamic dispatch. +type ITvf_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Tvf_prefix_no_args() ITvf_prefix_no_argsContext + AllTvf_argument() []ITvf_argumentContext + Tvf_argument(i int) ITvf_argumentContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsTvf_prefixContext differentiates from other interfaces. + IsTvf_prefixContext() +} + +type Tvf_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTvf_prefixContext() *Tvf_prefixContext { + var p = new(Tvf_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_tvf_prefix + return p +} + +func InitEmptyTvf_prefixContext(p *Tvf_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_tvf_prefix +} + +func (*Tvf_prefixContext) IsTvf_prefixContext() {} + +func NewTvf_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tvf_prefixContext { + var p = new(Tvf_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_tvf_prefix + + return p +} + +func (s *Tvf_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tvf_prefixContext) Tvf_prefix_no_args() ITvf_prefix_no_argsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITvf_prefix_no_argsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITvf_prefix_no_argsContext) +} + +func (s *Tvf_prefixContext) AllTvf_argument() []ITvf_argumentContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITvf_argumentContext); ok { + len++ + } + } + + tst := make([]ITvf_argumentContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITvf_argumentContext); ok { + tst[i] = t.(ITvf_argumentContext) + i++ + } + } + + return tst +} + +func (s *Tvf_prefixContext) Tvf_argument(i int) ITvf_argumentContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITvf_argumentContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITvf_argumentContext) +} + +func (s *Tvf_prefixContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Tvf_prefixContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Tvf_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tvf_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tvf_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTvf_prefix(s) + } +} + +func (s *Tvf_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTvf_prefix(s) + } +} + +func (s *Tvf_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTvf_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Tvf_prefix() (localctx ITvf_prefixContext) { + localctx = NewTvf_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 880, GoogleSQLParserRULE_tvf_prefix) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5385) + p.Tvf_prefix_no_args() + } + { + p.SetState(5386) + p.Tvf_argument() + } + p.SetState(5391) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(5387) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5388) + p.Tvf_argument() + } + + p.SetState(5393) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITvf_argumentContext is an interface to support dynamic dispatch. +type ITvf_argumentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + Descriptor_argument() IDescriptor_argumentContext + Table_clause() ITable_clauseContext + Model_clause() IModel_clauseContext + Connection_clause() IConnection_clauseContext + Named_argument() INamed_argumentContext + LR_BRACKET_SYMBOL() antlr.TerminalNode + RR_BRACKET_SYMBOL() antlr.TerminalNode + SELECT_SYMBOL() antlr.TerminalNode + WITH_SYMBOL() antlr.TerminalNode + + // IsTvf_argumentContext differentiates from other interfaces. + IsTvf_argumentContext() +} + +type Tvf_argumentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTvf_argumentContext() *Tvf_argumentContext { + var p = new(Tvf_argumentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_tvf_argument + return p +} + +func InitEmptyTvf_argumentContext(p *Tvf_argumentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_tvf_argument +} + +func (*Tvf_argumentContext) IsTvf_argumentContext() {} + +func NewTvf_argumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tvf_argumentContext { + var p = new(Tvf_argumentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_tvf_argument + + return p +} + +func (s *Tvf_argumentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tvf_argumentContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Tvf_argumentContext) Descriptor_argument() IDescriptor_argumentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescriptor_argumentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescriptor_argumentContext) +} + +func (s *Tvf_argumentContext) Table_clause() ITable_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_clauseContext) +} + +func (s *Tvf_argumentContext) Model_clause() IModel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_clauseContext) +} + +func (s *Tvf_argumentContext) Connection_clause() IConnection_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConnection_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConnection_clauseContext) +} + +func (s *Tvf_argumentContext) Named_argument() INamed_argumentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INamed_argumentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INamed_argumentContext) +} + +func (s *Tvf_argumentContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Tvf_argumentContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Tvf_argumentContext) SELECT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSELECT_SYMBOL, 0) +} + +func (s *Tvf_argumentContext) WITH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWITH_SYMBOL, 0) +} + +func (s *Tvf_argumentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tvf_argumentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tvf_argumentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTvf_argument(s) + } +} + +func (s *Tvf_argumentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTvf_argument(s) + } +} + +func (s *Tvf_argumentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTvf_argument(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Tvf_argument() (localctx ITvf_argumentContext) { + localctx = NewTvf_argumentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 882, GoogleSQLParserRULE_tvf_argument) + p.SetState(5424) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 684, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5394) + p.expression(0) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5395) + p.Descriptor_argument() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5396) + p.Table_clause() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5397) + p.Model_clause() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5398) + p.Connection_clause() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5399) + p.Named_argument() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(5400) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5401) + p.Table_clause() + } + { + p.SetState(5402) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.NotifyErrorListeners("Syntax error: Table arguments for table-valued function calls written as \"TABLE path\" must not be enclosed in parentheses. To fix this, replace (TABLE path) with TABLE path", nil, nil) + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(5405) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5406) + p.Model_clause() + } + { + p.SetState(5407) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.NotifyErrorListeners("Syntax error: Model arguments for table-valued function calls written as \"MODEL path\" must not be enclosed in parentheses. To fix this, replace (MODEL path) with MODEL path", nil, nil) + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(5410) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5411) + p.Connection_clause() + } + { + p.SetState(5412) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.NotifyErrorListeners("Syntax error: Connection arguments for table-valued function calls written as \"CONNECTION path\" must not be enclosed in parentheses. To fix this, replace (CONNECTION path) with CONNECTION path", nil, nil) + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(5415) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5416) + p.Named_argument() + } + { + p.SetState(5417) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.NotifyErrorListeners("Syntax error: Named arguments for table-valued function calls written as \"name => value\" must not be enclosed in parentheses. To fix this, replace (name => value) with name => value", nil, nil) + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(5420) + p.Match(GoogleSQLParserSELECT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.NotifyErrorListeners("Syntax error: Each subquery argument for table-valued function calls must be enclosed in parentheses. To fix this, replace SELECT... with (SELECT...)", nil, nil) + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(5422) + p.Match(GoogleSQLParserWITH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.NotifyErrorListeners("Syntax error: Each subquery argument for table-valued function calls must be enclosed in parentheses. To fix this, replace WITH... with (WITH...)", nil, nil) + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConnection_clauseContext is an interface to support dynamic dispatch. +type IConnection_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONNECTION_SYMBOL() antlr.TerminalNode + Path_expression_or_default() IPath_expression_or_defaultContext + + // IsConnection_clauseContext differentiates from other interfaces. + IsConnection_clauseContext() +} + +type Connection_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConnection_clauseContext() *Connection_clauseContext { + var p = new(Connection_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_connection_clause + return p +} + +func InitEmptyConnection_clauseContext(p *Connection_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_connection_clause +} + +func (*Connection_clauseContext) IsConnection_clauseContext() {} + +func NewConnection_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Connection_clauseContext { + var p = new(Connection_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_connection_clause + + return p +} + +func (s *Connection_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Connection_clauseContext) CONNECTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCONNECTION_SYMBOL, 0) +} + +func (s *Connection_clauseContext) Path_expression_or_default() IPath_expression_or_defaultContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expression_or_defaultContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expression_or_defaultContext) +} + +func (s *Connection_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Connection_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Connection_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterConnection_clause(s) + } +} + +func (s *Connection_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitConnection_clause(s) + } +} + +func (s *Connection_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitConnection_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Connection_clause() (localctx IConnection_clauseContext) { + localctx = NewConnection_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 884, GoogleSQLParserRULE_connection_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5426) + p.Match(GoogleSQLParserCONNECTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5427) + p.Path_expression_or_default() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPath_expression_or_defaultContext is an interface to support dynamic dispatch. +type IPath_expression_or_defaultContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Path_expression() IPath_expressionContext + DEFAULT_SYMBOL() antlr.TerminalNode + + // IsPath_expression_or_defaultContext differentiates from other interfaces. + IsPath_expression_or_defaultContext() +} + +type Path_expression_or_defaultContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPath_expression_or_defaultContext() *Path_expression_or_defaultContext { + var p = new(Path_expression_or_defaultContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_path_expression_or_default + return p +} + +func InitEmptyPath_expression_or_defaultContext(p *Path_expression_or_defaultContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_path_expression_or_default +} + +func (*Path_expression_or_defaultContext) IsPath_expression_or_defaultContext() {} + +func NewPath_expression_or_defaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Path_expression_or_defaultContext { + var p = new(Path_expression_or_defaultContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_path_expression_or_default + + return p +} + +func (s *Path_expression_or_defaultContext) GetParser() antlr.Parser { return s.parser } + +func (s *Path_expression_or_defaultContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Path_expression_or_defaultContext) DEFAULT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDEFAULT_SYMBOL, 0) +} + +func (s *Path_expression_or_defaultContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Path_expression_or_defaultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Path_expression_or_defaultContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPath_expression_or_default(s) + } +} + +func (s *Path_expression_or_defaultContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPath_expression_or_default(s) + } +} + +func (s *Path_expression_or_defaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPath_expression_or_default(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Path_expression_or_default() (localctx IPath_expression_or_defaultContext) { + localctx = NewPath_expression_or_defaultContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 886, GoogleSQLParserRULE_path_expression_or_default) + p.SetState(5431) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5429) + p.Path_expression() + } + + case GoogleSQLParserDEFAULT_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5430) + p.Match(GoogleSQLParserDEFAULT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDescriptor_argumentContext is an interface to support dynamic dispatch. +type IDescriptor_argumentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DESCRIPTOR_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + Descriptor_column_list() IDescriptor_column_listContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsDescriptor_argumentContext differentiates from other interfaces. + IsDescriptor_argumentContext() +} + +type Descriptor_argumentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescriptor_argumentContext() *Descriptor_argumentContext { + var p = new(Descriptor_argumentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_descriptor_argument + return p +} + +func InitEmptyDescriptor_argumentContext(p *Descriptor_argumentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_descriptor_argument +} + +func (*Descriptor_argumentContext) IsDescriptor_argumentContext() {} + +func NewDescriptor_argumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Descriptor_argumentContext { + var p = new(Descriptor_argumentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_descriptor_argument + + return p +} + +func (s *Descriptor_argumentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Descriptor_argumentContext) DESCRIPTOR_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDESCRIPTOR_SYMBOL, 0) +} + +func (s *Descriptor_argumentContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Descriptor_argumentContext) Descriptor_column_list() IDescriptor_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescriptor_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescriptor_column_listContext) +} + +func (s *Descriptor_argumentContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Descriptor_argumentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Descriptor_argumentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Descriptor_argumentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterDescriptor_argument(s) + } +} + +func (s *Descriptor_argumentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitDescriptor_argument(s) + } +} + +func (s *Descriptor_argumentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitDescriptor_argument(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Descriptor_argument() (localctx IDescriptor_argumentContext) { + localctx = NewDescriptor_argumentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 888, GoogleSQLParserRULE_descriptor_argument) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5433) + p.Match(GoogleSQLParserDESCRIPTOR_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5434) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5435) + p.Descriptor_column_list() + } + { + p.SetState(5436) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDescriptor_column_listContext is an interface to support dynamic dispatch. +type IDescriptor_column_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDescriptor_column() []IDescriptor_columnContext + Descriptor_column(i int) IDescriptor_columnContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsDescriptor_column_listContext differentiates from other interfaces. + IsDescriptor_column_listContext() +} + +type Descriptor_column_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescriptor_column_listContext() *Descriptor_column_listContext { + var p = new(Descriptor_column_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_descriptor_column_list + return p +} + +func InitEmptyDescriptor_column_listContext(p *Descriptor_column_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_descriptor_column_list +} + +func (*Descriptor_column_listContext) IsDescriptor_column_listContext() {} + +func NewDescriptor_column_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Descriptor_column_listContext { + var p = new(Descriptor_column_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_descriptor_column_list + + return p +} + +func (s *Descriptor_column_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Descriptor_column_listContext) AllDescriptor_column() []IDescriptor_columnContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDescriptor_columnContext); ok { + len++ + } + } + + tst := make([]IDescriptor_columnContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDescriptor_columnContext); ok { + tst[i] = t.(IDescriptor_columnContext) + i++ + } + } + + return tst +} + +func (s *Descriptor_column_listContext) Descriptor_column(i int) IDescriptor_columnContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescriptor_columnContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDescriptor_columnContext) +} + +func (s *Descriptor_column_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Descriptor_column_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Descriptor_column_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Descriptor_column_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Descriptor_column_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterDescriptor_column_list(s) + } +} + +func (s *Descriptor_column_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitDescriptor_column_list(s) + } +} + +func (s *Descriptor_column_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitDescriptor_column_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Descriptor_column_list() (localctx IDescriptor_column_listContext) { + localctx = NewDescriptor_column_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 890, GoogleSQLParserRULE_descriptor_column_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5438) + p.Descriptor_column() + } + p.SetState(5443) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(5439) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5440) + p.Descriptor_column() + } + + p.SetState(5445) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDescriptor_columnContext is an interface to support dynamic dispatch. +type IDescriptor_columnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsDescriptor_columnContext differentiates from other interfaces. + IsDescriptor_columnContext() +} + +type Descriptor_columnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescriptor_columnContext() *Descriptor_columnContext { + var p = new(Descriptor_columnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_descriptor_column + return p +} + +func InitEmptyDescriptor_columnContext(p *Descriptor_columnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_descriptor_column +} + +func (*Descriptor_columnContext) IsDescriptor_columnContext() {} + +func NewDescriptor_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Descriptor_columnContext { + var p = new(Descriptor_columnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_descriptor_column + + return p +} + +func (s *Descriptor_columnContext) GetParser() antlr.Parser { return s.parser } + +func (s *Descriptor_columnContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Descriptor_columnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Descriptor_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Descriptor_columnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterDescriptor_column(s) + } +} + +func (s *Descriptor_columnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitDescriptor_column(s) + } +} + +func (s *Descriptor_columnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitDescriptor_column(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Descriptor_column() (localctx IDescriptor_columnContext) { + localctx = NewDescriptor_columnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 892, GoogleSQLParserRULE_descriptor_column) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5446) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_clauseContext is an interface to support dynamic dispatch. +type ITable_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLE_SYMBOL() antlr.TerminalNode + Tvf_with_suffixes() ITvf_with_suffixesContext + Path_expression() IPath_expressionContext + + // IsTable_clauseContext differentiates from other interfaces. + IsTable_clauseContext() +} + +type Table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_clauseContext() *Table_clauseContext { + var p = new(Table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_clause + return p +} + +func InitEmptyTable_clauseContext(p *Table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_table_clause +} + +func (*Table_clauseContext) IsTable_clauseContext() {} + +func NewTable_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_clauseContext { + var p = new(Table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_table_clause + + return p +} + +func (s *Table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_clauseContext) TABLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTABLE_SYMBOL, 0) +} + +func (s *Table_clauseContext) Tvf_with_suffixes() ITvf_with_suffixesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITvf_with_suffixesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITvf_with_suffixesContext) +} + +func (s *Table_clauseContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTable_clause(s) + } +} + +func (s *Table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTable_clause(s) + } +} + +func (s *Table_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTable_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Table_clause() (localctx ITable_clauseContext) { + localctx = NewTable_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 894, GoogleSQLParserRULE_table_clause) + p.SetState(5452) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 687, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5448) + p.Match(GoogleSQLParserTABLE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5449) + p.Tvf_with_suffixes() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5450) + p.Match(GoogleSQLParserTABLE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5451) + p.Path_expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModel_clauseContext is an interface to support dynamic dispatch. +type IModel_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODEL_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + + // IsModel_clauseContext differentiates from other interfaces. + IsModel_clauseContext() +} + +type Model_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_clauseContext() *Model_clauseContext { + var p = new(Model_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_model_clause + return p +} + +func InitEmptyModel_clauseContext(p *Model_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_model_clause +} + +func (*Model_clauseContext) IsModel_clauseContext() {} + +func NewModel_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_clauseContext { + var p = new(Model_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_model_clause + + return p +} + +func (s *Model_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_clauseContext) MODEL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMODEL_SYMBOL, 0) +} + +func (s *Model_clauseContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Model_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterModel_clause(s) + } +} + +func (s *Model_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitModel_clause(s) + } +} + +func (s *Model_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitModel_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Model_clause() (localctx IModel_clauseContext) { + localctx = NewModel_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 896, GoogleSQLParserRULE_model_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5454) + p.Match(GoogleSQLParserMODEL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5455) + p.Path_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQualify_clause_nonreservedContext is an interface to support dynamic dispatch. +type IQualify_clause_nonreservedContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + QUALIFY_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + + // IsQualify_clause_nonreservedContext differentiates from other interfaces. + IsQualify_clause_nonreservedContext() +} + +type Qualify_clause_nonreservedContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQualify_clause_nonreservedContext() *Qualify_clause_nonreservedContext { + var p = new(Qualify_clause_nonreservedContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_qualify_clause_nonreserved + return p +} + +func InitEmptyQualify_clause_nonreservedContext(p *Qualify_clause_nonreservedContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_qualify_clause_nonreserved +} + +func (*Qualify_clause_nonreservedContext) IsQualify_clause_nonreservedContext() {} + +func NewQualify_clause_nonreservedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qualify_clause_nonreservedContext { + var p = new(Qualify_clause_nonreservedContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_qualify_clause_nonreserved + + return p +} + +func (s *Qualify_clause_nonreservedContext) GetParser() antlr.Parser { return s.parser } + +func (s *Qualify_clause_nonreservedContext) QUALIFY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserQUALIFY_SYMBOL, 0) +} + +func (s *Qualify_clause_nonreservedContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Qualify_clause_nonreservedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Qualify_clause_nonreservedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Qualify_clause_nonreservedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterQualify_clause_nonreserved(s) + } +} + +func (s *Qualify_clause_nonreservedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitQualify_clause_nonreserved(s) + } +} + +func (s *Qualify_clause_nonreservedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitQualify_clause_nonreserved(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Qualify_clause_nonreserved() (localctx IQualify_clause_nonreservedContext) { + localctx = NewQualify_clause_nonreservedContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 898, GoogleSQLParserRULE_qualify_clause_nonreserved) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5457) + p.Match(GoogleSQLParserQUALIFY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5458) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnpivot_clauseContext is an interface to support dynamic dispatch. +type IUnpivot_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNPIVOT_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + Path_expression_list_with_opt_parens() IPath_expression_list_with_opt_parensContext + FOR_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + IN_SYMBOL() antlr.TerminalNode + Unpivot_in_item_list() IUnpivot_in_item_listContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + Unpivot_nulls_filter() IUnpivot_nulls_filterContext + + // IsUnpivot_clauseContext differentiates from other interfaces. + IsUnpivot_clauseContext() +} + +type Unpivot_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnpivot_clauseContext() *Unpivot_clauseContext { + var p = new(Unpivot_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unpivot_clause + return p +} + +func InitEmptyUnpivot_clauseContext(p *Unpivot_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unpivot_clause +} + +func (*Unpivot_clauseContext) IsUnpivot_clauseContext() {} + +func NewUnpivot_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unpivot_clauseContext { + var p = new(Unpivot_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_unpivot_clause + + return p +} + +func (s *Unpivot_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unpivot_clauseContext) UNPIVOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUNPIVOT_SYMBOL, 0) +} + +func (s *Unpivot_clauseContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Unpivot_clauseContext) Path_expression_list_with_opt_parens() IPath_expression_list_with_opt_parensContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expression_list_with_opt_parensContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expression_list_with_opt_parensContext) +} + +func (s *Unpivot_clauseContext) FOR_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFOR_SYMBOL, 0) +} + +func (s *Unpivot_clauseContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Unpivot_clauseContext) IN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIN_SYMBOL, 0) +} + +func (s *Unpivot_clauseContext) Unpivot_in_item_list() IUnpivot_in_item_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnpivot_in_item_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnpivot_in_item_listContext) +} + +func (s *Unpivot_clauseContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Unpivot_clauseContext) Unpivot_nulls_filter() IUnpivot_nulls_filterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnpivot_nulls_filterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnpivot_nulls_filterContext) +} + +func (s *Unpivot_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unpivot_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unpivot_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterUnpivot_clause(s) + } +} + +func (s *Unpivot_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitUnpivot_clause(s) + } +} + +func (s *Unpivot_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitUnpivot_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Unpivot_clause() (localctx IUnpivot_clauseContext) { + localctx = NewUnpivot_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 900, GoogleSQLParserRULE_unpivot_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5460) + p.Match(GoogleSQLParserUNPIVOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5462) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserEXCLUDE_SYMBOL || _la == GoogleSQLParserINCLUDE_SYMBOL { + { + p.SetState(5461) + p.Unpivot_nulls_filter() + } + + } + { + p.SetState(5464) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5465) + p.Path_expression_list_with_opt_parens() + } + { + p.SetState(5466) + p.Match(GoogleSQLParserFOR_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5467) + p.Path_expression() + } + { + p.SetState(5468) + p.Match(GoogleSQLParserIN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5469) + p.Unpivot_in_item_list() + } + { + p.SetState(5470) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnpivot_in_item_listContext is an interface to support dynamic dispatch. +type IUnpivot_in_item_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Unpivot_in_item_list_prefix() IUnpivot_in_item_list_prefixContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsUnpivot_in_item_listContext differentiates from other interfaces. + IsUnpivot_in_item_listContext() +} + +type Unpivot_in_item_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnpivot_in_item_listContext() *Unpivot_in_item_listContext { + var p = new(Unpivot_in_item_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unpivot_in_item_list + return p +} + +func InitEmptyUnpivot_in_item_listContext(p *Unpivot_in_item_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unpivot_in_item_list +} + +func (*Unpivot_in_item_listContext) IsUnpivot_in_item_listContext() {} + +func NewUnpivot_in_item_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unpivot_in_item_listContext { + var p = new(Unpivot_in_item_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_unpivot_in_item_list + + return p +} + +func (s *Unpivot_in_item_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unpivot_in_item_listContext) Unpivot_in_item_list_prefix() IUnpivot_in_item_list_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnpivot_in_item_list_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnpivot_in_item_list_prefixContext) +} + +func (s *Unpivot_in_item_listContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Unpivot_in_item_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unpivot_in_item_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unpivot_in_item_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterUnpivot_in_item_list(s) + } +} + +func (s *Unpivot_in_item_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitUnpivot_in_item_list(s) + } +} + +func (s *Unpivot_in_item_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitUnpivot_in_item_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Unpivot_in_item_list() (localctx IUnpivot_in_item_listContext) { + localctx = NewUnpivot_in_item_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 902, GoogleSQLParserRULE_unpivot_in_item_list) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5472) + p.unpivot_in_item_list_prefix(0) + } + { + p.SetState(5473) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnpivot_in_item_list_prefixContext is an interface to support dynamic dispatch. +type IUnpivot_in_item_list_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + Unpivot_in_item() IUnpivot_in_itemContext + Unpivot_in_item_list_prefix() IUnpivot_in_item_list_prefixContext + COMMA_SYMBOL() antlr.TerminalNode + + // IsUnpivot_in_item_list_prefixContext differentiates from other interfaces. + IsUnpivot_in_item_list_prefixContext() +} + +type Unpivot_in_item_list_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnpivot_in_item_list_prefixContext() *Unpivot_in_item_list_prefixContext { + var p = new(Unpivot_in_item_list_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unpivot_in_item_list_prefix + return p +} + +func InitEmptyUnpivot_in_item_list_prefixContext(p *Unpivot_in_item_list_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unpivot_in_item_list_prefix +} + +func (*Unpivot_in_item_list_prefixContext) IsUnpivot_in_item_list_prefixContext() {} + +func NewUnpivot_in_item_list_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unpivot_in_item_list_prefixContext { + var p = new(Unpivot_in_item_list_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_unpivot_in_item_list_prefix + + return p +} + +func (s *Unpivot_in_item_list_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unpivot_in_item_list_prefixContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Unpivot_in_item_list_prefixContext) Unpivot_in_item() IUnpivot_in_itemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnpivot_in_itemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnpivot_in_itemContext) +} + +func (s *Unpivot_in_item_list_prefixContext) Unpivot_in_item_list_prefix() IUnpivot_in_item_list_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnpivot_in_item_list_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnpivot_in_item_list_prefixContext) +} + +func (s *Unpivot_in_item_list_prefixContext) COMMA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, 0) +} + +func (s *Unpivot_in_item_list_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unpivot_in_item_list_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unpivot_in_item_list_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterUnpivot_in_item_list_prefix(s) + } +} + +func (s *Unpivot_in_item_list_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitUnpivot_in_item_list_prefix(s) + } +} + +func (s *Unpivot_in_item_list_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitUnpivot_in_item_list_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Unpivot_in_item_list_prefix() (localctx IUnpivot_in_item_list_prefixContext) { + return p.unpivot_in_item_list_prefix(0) +} + +func (p *GoogleSQLParser) unpivot_in_item_list_prefix(_p int) (localctx IUnpivot_in_item_list_prefixContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewUnpivot_in_item_list_prefixContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IUnpivot_in_item_list_prefixContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 904 + p.EnterRecursionRule(localctx, 904, GoogleSQLParserRULE_unpivot_in_item_list_prefix, _p) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5476) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5477) + p.Unpivot_in_item() + } + + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(5484) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 689, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + localctx = NewUnpivot_in_item_list_prefixContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_unpivot_in_item_list_prefix) + p.SetState(5479) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(5480) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5481) + p.Unpivot_in_item() + } + + } + p.SetState(5486) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 689, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnpivot_in_itemContext is an interface to support dynamic dispatch. +type IUnpivot_in_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Path_expression_list_with_opt_parens() IPath_expression_list_with_opt_parensContext + Opt_as_string_or_integer() IOpt_as_string_or_integerContext + + // IsUnpivot_in_itemContext differentiates from other interfaces. + IsUnpivot_in_itemContext() +} + +type Unpivot_in_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnpivot_in_itemContext() *Unpivot_in_itemContext { + var p = new(Unpivot_in_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unpivot_in_item + return p +} + +func InitEmptyUnpivot_in_itemContext(p *Unpivot_in_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unpivot_in_item +} + +func (*Unpivot_in_itemContext) IsUnpivot_in_itemContext() {} + +func NewUnpivot_in_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unpivot_in_itemContext { + var p = new(Unpivot_in_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_unpivot_in_item + + return p +} + +func (s *Unpivot_in_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unpivot_in_itemContext) Path_expression_list_with_opt_parens() IPath_expression_list_with_opt_parensContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expression_list_with_opt_parensContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expression_list_with_opt_parensContext) +} + +func (s *Unpivot_in_itemContext) Opt_as_string_or_integer() IOpt_as_string_or_integerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_as_string_or_integerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_as_string_or_integerContext) +} + +func (s *Unpivot_in_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unpivot_in_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unpivot_in_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterUnpivot_in_item(s) + } +} + +func (s *Unpivot_in_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitUnpivot_in_item(s) + } +} + +func (s *Unpivot_in_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitUnpivot_in_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Unpivot_in_item() (localctx IUnpivot_in_itemContext) { + localctx = NewUnpivot_in_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 906, GoogleSQLParserRULE_unpivot_in_item) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5487) + p.Path_expression_list_with_opt_parens() + } + p.SetState(5489) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 690, p.GetParserRuleContext()) == 1 { + { + p.SetState(5488) + p.Opt_as_string_or_integer() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_as_string_or_integerContext is an interface to support dynamic dispatch. +type IOpt_as_string_or_integerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + String_literal() IString_literalContext + AS_SYMBOL() antlr.TerminalNode + Integer_literal() IInteger_literalContext + + // IsOpt_as_string_or_integerContext differentiates from other interfaces. + IsOpt_as_string_or_integerContext() +} + +type Opt_as_string_or_integerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_as_string_or_integerContext() *Opt_as_string_or_integerContext { + var p = new(Opt_as_string_or_integerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_as_string_or_integer + return p +} + +func InitEmptyOpt_as_string_or_integerContext(p *Opt_as_string_or_integerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_as_string_or_integer +} + +func (*Opt_as_string_or_integerContext) IsOpt_as_string_or_integerContext() {} + +func NewOpt_as_string_or_integerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_as_string_or_integerContext { + var p = new(Opt_as_string_or_integerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_as_string_or_integer + + return p +} + +func (s *Opt_as_string_or_integerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_as_string_or_integerContext) String_literal() IString_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_literalContext) +} + +func (s *Opt_as_string_or_integerContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Opt_as_string_or_integerContext) Integer_literal() IInteger_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInteger_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInteger_literalContext) +} + +func (s *Opt_as_string_or_integerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_as_string_or_integerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_as_string_or_integerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_as_string_or_integer(s) + } +} + +func (s *Opt_as_string_or_integerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_as_string_or_integer(s) + } +} + +func (s *Opt_as_string_or_integerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_as_string_or_integer(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_as_string_or_integer() (localctx IOpt_as_string_or_integerContext) { + localctx = NewOpt_as_string_or_integerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 908, GoogleSQLParserRULE_opt_as_string_or_integer) + var _la int + + p.SetState(5499) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 693, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(5492) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(5491) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5494) + p.string_literal(0) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(5496) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(5495) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5498) + p.Integer_literal() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPath_expression_list_with_opt_parensContext is an interface to support dynamic dispatch. +type IPath_expression_list_with_opt_parensContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + Path_expression_list() IPath_expression_listContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsPath_expression_list_with_opt_parensContext differentiates from other interfaces. + IsPath_expression_list_with_opt_parensContext() +} + +type Path_expression_list_with_opt_parensContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPath_expression_list_with_opt_parensContext() *Path_expression_list_with_opt_parensContext { + var p = new(Path_expression_list_with_opt_parensContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_path_expression_list_with_opt_parens + return p +} + +func InitEmptyPath_expression_list_with_opt_parensContext(p *Path_expression_list_with_opt_parensContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_path_expression_list_with_opt_parens +} + +func (*Path_expression_list_with_opt_parensContext) IsPath_expression_list_with_opt_parensContext() {} + +func NewPath_expression_list_with_opt_parensContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Path_expression_list_with_opt_parensContext { + var p = new(Path_expression_list_with_opt_parensContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_path_expression_list_with_opt_parens + + return p +} + +func (s *Path_expression_list_with_opt_parensContext) GetParser() antlr.Parser { return s.parser } + +func (s *Path_expression_list_with_opt_parensContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Path_expression_list_with_opt_parensContext) Path_expression_list() IPath_expression_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expression_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expression_listContext) +} + +func (s *Path_expression_list_with_opt_parensContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Path_expression_list_with_opt_parensContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Path_expression_list_with_opt_parensContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Path_expression_list_with_opt_parensContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPath_expression_list_with_opt_parens(s) + } +} + +func (s *Path_expression_list_with_opt_parensContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPath_expression_list_with_opt_parens(s) + } +} + +func (s *Path_expression_list_with_opt_parensContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPath_expression_list_with_opt_parens(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Path_expression_list_with_opt_parens() (localctx IPath_expression_list_with_opt_parensContext) { + localctx = NewPath_expression_list_with_opt_parensContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 910, GoogleSQLParserRULE_path_expression_list_with_opt_parens) + p.SetState(5506) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserLR_BRACKET_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5501) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5502) + p.Path_expression_list() + } + { + p.SetState(5503) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5505) + p.Path_expression_list() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPath_expression_listContext is an interface to support dynamic dispatch. +type IPath_expression_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllPath_expression() []IPath_expressionContext + Path_expression(i int) IPath_expressionContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsPath_expression_listContext differentiates from other interfaces. + IsPath_expression_listContext() +} + +type Path_expression_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPath_expression_listContext() *Path_expression_listContext { + var p = new(Path_expression_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_path_expression_list + return p +} + +func InitEmptyPath_expression_listContext(p *Path_expression_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_path_expression_list +} + +func (*Path_expression_listContext) IsPath_expression_listContext() {} + +func NewPath_expression_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Path_expression_listContext { + var p = new(Path_expression_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_path_expression_list + + return p +} + +func (s *Path_expression_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Path_expression_listContext) AllPath_expression() []IPath_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPath_expressionContext); ok { + len++ + } + } + + tst := make([]IPath_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPath_expressionContext); ok { + tst[i] = t.(IPath_expressionContext) + i++ + } + } + + return tst +} + +func (s *Path_expression_listContext) Path_expression(i int) IPath_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Path_expression_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Path_expression_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Path_expression_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Path_expression_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Path_expression_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPath_expression_list(s) + } +} + +func (s *Path_expression_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPath_expression_list(s) + } +} + +func (s *Path_expression_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPath_expression_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Path_expression_list() (localctx IPath_expression_listContext) { + localctx = NewPath_expression_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 912, GoogleSQLParserRULE_path_expression_list) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5508) + p.Path_expression() + } + p.SetState(5513) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 695, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5509) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5510) + p.Path_expression() + } + + } + p.SetState(5515) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 695, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnpivot_nulls_filterContext is an interface to support dynamic dispatch. +type IUnpivot_nulls_filterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXCLUDE_SYMBOL() antlr.TerminalNode + NULLS_SYMBOL() antlr.TerminalNode + INCLUDE_SYMBOL() antlr.TerminalNode + + // IsUnpivot_nulls_filterContext differentiates from other interfaces. + IsUnpivot_nulls_filterContext() +} + +type Unpivot_nulls_filterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnpivot_nulls_filterContext() *Unpivot_nulls_filterContext { + var p = new(Unpivot_nulls_filterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unpivot_nulls_filter + return p +} + +func InitEmptyUnpivot_nulls_filterContext(p *Unpivot_nulls_filterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unpivot_nulls_filter +} + +func (*Unpivot_nulls_filterContext) IsUnpivot_nulls_filterContext() {} + +func NewUnpivot_nulls_filterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unpivot_nulls_filterContext { + var p = new(Unpivot_nulls_filterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_unpivot_nulls_filter + + return p +} + +func (s *Unpivot_nulls_filterContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unpivot_nulls_filterContext) EXCLUDE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXCLUDE_SYMBOL, 0) +} + +func (s *Unpivot_nulls_filterContext) NULLS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNULLS_SYMBOL, 0) +} + +func (s *Unpivot_nulls_filterContext) INCLUDE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINCLUDE_SYMBOL, 0) +} + +func (s *Unpivot_nulls_filterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unpivot_nulls_filterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unpivot_nulls_filterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterUnpivot_nulls_filter(s) + } +} + +func (s *Unpivot_nulls_filterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitUnpivot_nulls_filter(s) + } +} + +func (s *Unpivot_nulls_filterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitUnpivot_nulls_filter(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Unpivot_nulls_filter() (localctx IUnpivot_nulls_filterContext) { + localctx = NewUnpivot_nulls_filterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 914, GoogleSQLParserRULE_unpivot_nulls_filter) + p.SetState(5520) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserEXCLUDE_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5516) + p.Match(GoogleSQLParserEXCLUDE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5517) + p.Match(GoogleSQLParserNULLS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserINCLUDE_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5518) + p.Match(GoogleSQLParserINCLUDE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5519) + p.Match(GoogleSQLParserNULLS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPivot_clauseContext is an interface to support dynamic dispatch. +type IPivot_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PIVOT_SYMBOL() antlr.TerminalNode + AllLR_BRACKET_SYMBOL() []antlr.TerminalNode + LR_BRACKET_SYMBOL(i int) antlr.TerminalNode + Pivot_expression_list() IPivot_expression_listContext + FOR_SYMBOL() antlr.TerminalNode + Expression_higher_prec_than_and() IExpression_higher_prec_than_andContext + IN_SYMBOL() antlr.TerminalNode + Pivot_value_list() IPivot_value_listContext + AllRR_BRACKET_SYMBOL() []antlr.TerminalNode + RR_BRACKET_SYMBOL(i int) antlr.TerminalNode + + // IsPivot_clauseContext differentiates from other interfaces. + IsPivot_clauseContext() +} + +type Pivot_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPivot_clauseContext() *Pivot_clauseContext { + var p = new(Pivot_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_pivot_clause + return p +} + +func InitEmptyPivot_clauseContext(p *Pivot_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_pivot_clause +} + +func (*Pivot_clauseContext) IsPivot_clauseContext() {} + +func NewPivot_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pivot_clauseContext { + var p = new(Pivot_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_pivot_clause + + return p +} + +func (s *Pivot_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pivot_clauseContext) PIVOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPIVOT_SYMBOL, 0) +} + +func (s *Pivot_clauseContext) AllLR_BRACKET_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserLR_BRACKET_SYMBOL) +} + +func (s *Pivot_clauseContext) LR_BRACKET_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, i) +} + +func (s *Pivot_clauseContext) Pivot_expression_list() IPivot_expression_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_expression_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPivot_expression_listContext) +} + +func (s *Pivot_clauseContext) FOR_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFOR_SYMBOL, 0) +} + +func (s *Pivot_clauseContext) Expression_higher_prec_than_and() IExpression_higher_prec_than_andContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_higher_prec_than_andContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpression_higher_prec_than_andContext) +} + +func (s *Pivot_clauseContext) IN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIN_SYMBOL, 0) +} + +func (s *Pivot_clauseContext) Pivot_value_list() IPivot_value_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_value_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPivot_value_listContext) +} + +func (s *Pivot_clauseContext) AllRR_BRACKET_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserRR_BRACKET_SYMBOL) +} + +func (s *Pivot_clauseContext) RR_BRACKET_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, i) +} + +func (s *Pivot_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pivot_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pivot_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPivot_clause(s) + } +} + +func (s *Pivot_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPivot_clause(s) + } +} + +func (s *Pivot_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPivot_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Pivot_clause() (localctx IPivot_clauseContext) { + localctx = NewPivot_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 916, GoogleSQLParserRULE_pivot_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5522) + p.Match(GoogleSQLParserPIVOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5523) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5524) + p.Pivot_expression_list() + } + { + p.SetState(5525) + p.Match(GoogleSQLParserFOR_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5526) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5527) + p.Match(GoogleSQLParserIN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5528) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5529) + p.Pivot_value_list() + } + { + p.SetState(5530) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5531) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPivot_expression_listContext is an interface to support dynamic dispatch. +type IPivot_expression_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllPivot_expression() []IPivot_expressionContext + Pivot_expression(i int) IPivot_expressionContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsPivot_expression_listContext differentiates from other interfaces. + IsPivot_expression_listContext() +} + +type Pivot_expression_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPivot_expression_listContext() *Pivot_expression_listContext { + var p = new(Pivot_expression_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_pivot_expression_list + return p +} + +func InitEmptyPivot_expression_listContext(p *Pivot_expression_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_pivot_expression_list +} + +func (*Pivot_expression_listContext) IsPivot_expression_listContext() {} + +func NewPivot_expression_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pivot_expression_listContext { + var p = new(Pivot_expression_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_pivot_expression_list + + return p +} + +func (s *Pivot_expression_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pivot_expression_listContext) AllPivot_expression() []IPivot_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPivot_expressionContext); ok { + len++ + } + } + + tst := make([]IPivot_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPivot_expressionContext); ok { + tst[i] = t.(IPivot_expressionContext) + i++ + } + } + + return tst +} + +func (s *Pivot_expression_listContext) Pivot_expression(i int) IPivot_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPivot_expressionContext) +} + +func (s *Pivot_expression_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Pivot_expression_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Pivot_expression_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pivot_expression_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pivot_expression_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPivot_expression_list(s) + } +} + +func (s *Pivot_expression_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPivot_expression_list(s) + } +} + +func (s *Pivot_expression_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPivot_expression_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Pivot_expression_list() (localctx IPivot_expression_listContext) { + localctx = NewPivot_expression_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 918, GoogleSQLParserRULE_pivot_expression_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5533) + p.Pivot_expression() + } + p.SetState(5538) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(5534) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5535) + p.Pivot_expression() + } + + p.SetState(5540) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPivot_expressionContext is an interface to support dynamic dispatch. +type IPivot_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + As_alias() IAs_aliasContext + + // IsPivot_expressionContext differentiates from other interfaces. + IsPivot_expressionContext() +} + +type Pivot_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPivot_expressionContext() *Pivot_expressionContext { + var p = new(Pivot_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_pivot_expression + return p +} + +func InitEmptyPivot_expressionContext(p *Pivot_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_pivot_expression +} + +func (*Pivot_expressionContext) IsPivot_expressionContext() {} + +func NewPivot_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pivot_expressionContext { + var p = new(Pivot_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_pivot_expression + + return p +} + +func (s *Pivot_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pivot_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Pivot_expressionContext) As_alias() IAs_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_aliasContext) +} + +func (s *Pivot_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pivot_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pivot_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPivot_expression(s) + } +} + +func (s *Pivot_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPivot_expression(s) + } +} + +func (s *Pivot_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPivot_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Pivot_expression() (localctx IPivot_expressionContext) { + localctx = NewPivot_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 920, GoogleSQLParserRULE_pivot_expression) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5541) + p.expression(0) + } + p.SetState(5543) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-58)) & ^0x3f) == 0 && ((int64(1)<<(_la-58))&-6981105432269881343) != 0) || ((int64((_la-122)) & ^0x3f) == 0 && ((int64(1)<<(_la-122))&-1) != 0) || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&-1) != 0) || ((int64((_la-250)) & ^0x3f) == 0 && ((int64(1)<<(_la-250))&35184372088703) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&33488865) != 0) { + { + p.SetState(5542) + p.As_alias() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPivot_value_listContext is an interface to support dynamic dispatch. +type IPivot_value_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllPivot_value() []IPivot_valueContext + Pivot_value(i int) IPivot_valueContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsPivot_value_listContext differentiates from other interfaces. + IsPivot_value_listContext() +} + +type Pivot_value_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPivot_value_listContext() *Pivot_value_listContext { + var p = new(Pivot_value_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_pivot_value_list + return p +} + +func InitEmptyPivot_value_listContext(p *Pivot_value_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_pivot_value_list +} + +func (*Pivot_value_listContext) IsPivot_value_listContext() {} + +func NewPivot_value_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pivot_value_listContext { + var p = new(Pivot_value_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_pivot_value_list + + return p +} + +func (s *Pivot_value_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pivot_value_listContext) AllPivot_value() []IPivot_valueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPivot_valueContext); ok { + len++ + } + } + + tst := make([]IPivot_valueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPivot_valueContext); ok { + tst[i] = t.(IPivot_valueContext) + i++ + } + } + + return tst +} + +func (s *Pivot_value_listContext) Pivot_value(i int) IPivot_valueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_valueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPivot_valueContext) +} + +func (s *Pivot_value_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Pivot_value_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Pivot_value_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pivot_value_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pivot_value_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPivot_value_list(s) + } +} + +func (s *Pivot_value_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPivot_value_list(s) + } +} + +func (s *Pivot_value_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPivot_value_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Pivot_value_list() (localctx IPivot_value_listContext) { + localctx = NewPivot_value_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 922, GoogleSQLParserRULE_pivot_value_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5545) + p.Pivot_value() + } + p.SetState(5550) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(5546) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5547) + p.Pivot_value() + } + + p.SetState(5552) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPivot_valueContext is an interface to support dynamic dispatch. +type IPivot_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + As_alias() IAs_aliasContext + + // IsPivot_valueContext differentiates from other interfaces. + IsPivot_valueContext() +} + +type Pivot_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPivot_valueContext() *Pivot_valueContext { + var p = new(Pivot_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_pivot_value + return p +} + +func InitEmptyPivot_valueContext(p *Pivot_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_pivot_value +} + +func (*Pivot_valueContext) IsPivot_valueContext() {} + +func NewPivot_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pivot_valueContext { + var p = new(Pivot_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_pivot_value + + return p +} + +func (s *Pivot_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pivot_valueContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Pivot_valueContext) As_alias() IAs_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_aliasContext) +} + +func (s *Pivot_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pivot_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pivot_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPivot_value(s) + } +} + +func (s *Pivot_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPivot_value(s) + } +} + +func (s *Pivot_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPivot_value(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Pivot_value() (localctx IPivot_valueContext) { + localctx = NewPivot_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 924, GoogleSQLParserRULE_pivot_value) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5553) + p.expression(0) + } + p.SetState(5555) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-58)) & ^0x3f) == 0 && ((int64(1)<<(_la-58))&-6981105432269881343) != 0) || ((int64((_la-122)) & ^0x3f) == 0 && ((int64(1)<<(_la-122))&-1) != 0) || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&-1) != 0) || ((int64((_la-250)) & ^0x3f) == 0 && ((int64(1)<<(_la-250))&35184372088703) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&33488865) != 0) { + { + p.SetState(5554) + p.As_alias() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITvf_prefix_no_argsContext is an interface to support dynamic dispatch. +type ITvf_prefix_no_argsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Path_expression() IPath_expressionContext + IF_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsTvf_prefix_no_argsContext differentiates from other interfaces. + IsTvf_prefix_no_argsContext() +} + +type Tvf_prefix_no_argsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTvf_prefix_no_argsContext() *Tvf_prefix_no_argsContext { + var p = new(Tvf_prefix_no_argsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_tvf_prefix_no_args + return p +} + +func InitEmptyTvf_prefix_no_argsContext(p *Tvf_prefix_no_argsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_tvf_prefix_no_args +} + +func (*Tvf_prefix_no_argsContext) IsTvf_prefix_no_argsContext() {} + +func NewTvf_prefix_no_argsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tvf_prefix_no_argsContext { + var p = new(Tvf_prefix_no_argsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_tvf_prefix_no_args + + return p +} + +func (s *Tvf_prefix_no_argsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tvf_prefix_no_argsContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Tvf_prefix_no_argsContext) IF_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIF_SYMBOL, 0) +} + +func (s *Tvf_prefix_no_argsContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Tvf_prefix_no_argsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tvf_prefix_no_argsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tvf_prefix_no_argsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTvf_prefix_no_args(s) + } +} + +func (s *Tvf_prefix_no_argsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTvf_prefix_no_args(s) + } +} + +func (s *Tvf_prefix_no_argsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTvf_prefix_no_args(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Tvf_prefix_no_args() (localctx ITvf_prefix_no_argsContext) { + localctx = NewTvf_prefix_no_argsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 926, GoogleSQLParserRULE_tvf_prefix_no_args) + p.SetState(5560) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5557) + p.Path_expression() + } + + case GoogleSQLParserIF_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5558) + p.Match(GoogleSQLParserIF_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5559) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJoin_typeContext is an interface to support dynamic dispatch. +type IJoin_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CROSS_SYMBOL() antlr.TerminalNode + FULL_SYMBOL() antlr.TerminalNode + Opt_outer() IOpt_outerContext + INNER_SYMBOL() antlr.TerminalNode + LEFT_SYMBOL() antlr.TerminalNode + RIGHT_SYMBOL() antlr.TerminalNode + + // IsJoin_typeContext differentiates from other interfaces. + IsJoin_typeContext() +} + +type Join_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJoin_typeContext() *Join_typeContext { + var p = new(Join_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_join_type + return p +} + +func InitEmptyJoin_typeContext(p *Join_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_join_type +} + +func (*Join_typeContext) IsJoin_typeContext() {} + +func NewJoin_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_typeContext { + var p = new(Join_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_join_type + + return p +} + +func (s *Join_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Join_typeContext) CROSS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCROSS_SYMBOL, 0) +} + +func (s *Join_typeContext) FULL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFULL_SYMBOL, 0) +} + +func (s *Join_typeContext) Opt_outer() IOpt_outerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_outerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_outerContext) +} + +func (s *Join_typeContext) INNER_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINNER_SYMBOL, 0) +} + +func (s *Join_typeContext) LEFT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLEFT_SYMBOL, 0) +} + +func (s *Join_typeContext) RIGHT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRIGHT_SYMBOL, 0) +} + +func (s *Join_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Join_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Join_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterJoin_type(s) + } +} + +func (s *Join_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitJoin_type(s) + } +} + +func (s *Join_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitJoin_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Join_type() (localctx IJoin_typeContext) { + localctx = NewJoin_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 928, GoogleSQLParserRULE_join_type) + var _la int + + p.SetState(5576) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserCROSS_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5562) + p.Match(GoogleSQLParserCROSS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserFULL_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5563) + p.Match(GoogleSQLParserFULL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5565) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOUTER_SYMBOL { + { + p.SetState(5564) + p.Opt_outer() + } + + } + + case GoogleSQLParserINNER_SYMBOL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5567) + p.Match(GoogleSQLParserINNER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserLEFT_SYMBOL: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5568) + p.Match(GoogleSQLParserLEFT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5570) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOUTER_SYMBOL { + { + p.SetState(5569) + p.Opt_outer() + } + + } + + case GoogleSQLParserRIGHT_SYMBOL: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5572) + p.Match(GoogleSQLParserRIGHT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5574) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserOUTER_SYMBOL { + { + p.SetState(5573) + p.Opt_outer() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_naturalContext is an interface to support dynamic dispatch. +type IOpt_naturalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NATURAL_SYMBOL() antlr.TerminalNode + + // IsOpt_naturalContext differentiates from other interfaces. + IsOpt_naturalContext() +} + +type Opt_naturalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_naturalContext() *Opt_naturalContext { + var p = new(Opt_naturalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_natural + return p +} + +func InitEmptyOpt_naturalContext(p *Opt_naturalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_natural +} + +func (*Opt_naturalContext) IsOpt_naturalContext() {} + +func NewOpt_naturalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_naturalContext { + var p = new(Opt_naturalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_natural + + return p +} + +func (s *Opt_naturalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_naturalContext) NATURAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNATURAL_SYMBOL, 0) +} + +func (s *Opt_naturalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_naturalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_naturalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_natural(s) + } +} + +func (s *Opt_naturalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_natural(s) + } +} + +func (s *Opt_naturalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_natural(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_natural() (localctx IOpt_naturalContext) { + localctx = NewOpt_naturalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 930, GoogleSQLParserRULE_opt_natural) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5578) + p.Match(GoogleSQLParserNATURAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOn_clauseContext is an interface to support dynamic dispatch. +type IOn_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + + // IsOn_clauseContext differentiates from other interfaces. + IsOn_clauseContext() +} + +type On_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOn_clauseContext() *On_clauseContext { + var p = new(On_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_on_clause + return p +} + +func InitEmptyOn_clauseContext(p *On_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_on_clause +} + +func (*On_clauseContext) IsOn_clauseContext() {} + +func NewOn_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_clauseContext { + var p = new(On_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_on_clause + + return p +} + +func (s *On_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_clauseContext) ON_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserON_SYMBOL, 0) +} + +func (s *On_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *On_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOn_clause(s) + } +} + +func (s *On_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOn_clause(s) + } +} + +func (s *On_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOn_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) On_clause() (localctx IOn_clauseContext) { + localctx = NewOn_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 932, GoogleSQLParserRULE_on_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5580) + p.Match(GoogleSQLParserON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5581) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_listContext is an interface to support dynamic dispatch. +type ISelect_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSelect_list_item() []ISelect_list_itemContext + Select_list_item(i int) ISelect_list_itemContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsSelect_listContext differentiates from other interfaces. + IsSelect_listContext() +} + +type Select_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_listContext() *Select_listContext { + var p = new(Select_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_select_list + return p +} + +func InitEmptySelect_listContext(p *Select_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_select_list +} + +func (*Select_listContext) IsSelect_listContext() {} + +func NewSelect_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_listContext { + var p = new(Select_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_select_list + + return p +} + +func (s *Select_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_listContext) AllSelect_list_item() []ISelect_list_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISelect_list_itemContext); ok { + len++ + } + } + + tst := make([]ISelect_list_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISelect_list_itemContext); ok { + tst[i] = t.(ISelect_list_itemContext) + i++ + } + } + + return tst +} + +func (s *Select_listContext) Select_list_item(i int) ISelect_list_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_list_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISelect_list_itemContext) +} + +func (s *Select_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Select_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Select_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSelect_list(s) + } +} + +func (s *Select_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSelect_list(s) + } +} + +func (s *Select_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSelect_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Select_list() (localctx ISelect_listContext) { + localctx = NewSelect_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 934, GoogleSQLParserRULE_select_list) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5583) + p.Select_list_item() + } + p.SetState(5588) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 706, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5584) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5585) + p.Select_list_item() + } + + } + p.SetState(5590) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 706, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(5592) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 707, p.GetParserRuleContext()) == 1 { + { + p.SetState(5591) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_list_itemContext is an interface to support dynamic dispatch. +type ISelect_list_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Select_column_expr() ISelect_column_exprContext + Select_column_dot_star() ISelect_column_dot_starContext + Select_column_star() ISelect_column_starContext + + // IsSelect_list_itemContext differentiates from other interfaces. + IsSelect_list_itemContext() +} + +type Select_list_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_list_itemContext() *Select_list_itemContext { + var p = new(Select_list_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_select_list_item + return p +} + +func InitEmptySelect_list_itemContext(p *Select_list_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_select_list_item +} + +func (*Select_list_itemContext) IsSelect_list_itemContext() {} + +func NewSelect_list_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_list_itemContext { + var p = new(Select_list_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_select_list_item + + return p +} + +func (s *Select_list_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_list_itemContext) Select_column_expr() ISelect_column_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_column_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_column_exprContext) +} + +func (s *Select_list_itemContext) Select_column_dot_star() ISelect_column_dot_starContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_column_dot_starContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_column_dot_starContext) +} + +func (s *Select_list_itemContext) Select_column_star() ISelect_column_starContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_column_starContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_column_starContext) +} + +func (s *Select_list_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_list_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_list_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSelect_list_item(s) + } +} + +func (s *Select_list_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSelect_list_item(s) + } +} + +func (s *Select_list_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSelect_list_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Select_list_item() (localctx ISelect_list_itemContext) { + localctx = NewSelect_list_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 936, GoogleSQLParserRULE_select_list_item) + p.SetState(5597) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 708, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5594) + p.Select_column_expr() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5595) + p.Select_column_dot_star() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5596) + p.Select_column_star() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_column_starContext is an interface to support dynamic dispatch. +type ISelect_column_starContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MULTIPLY_OPERATOR() antlr.TerminalNode + Star_modifiers() IStar_modifiersContext + + // IsSelect_column_starContext differentiates from other interfaces. + IsSelect_column_starContext() +} + +type Select_column_starContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_column_starContext() *Select_column_starContext { + var p = new(Select_column_starContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_select_column_star + return p +} + +func InitEmptySelect_column_starContext(p *Select_column_starContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_select_column_star +} + +func (*Select_column_starContext) IsSelect_column_starContext() {} + +func NewSelect_column_starContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_column_starContext { + var p = new(Select_column_starContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_select_column_star + + return p +} + +func (s *Select_column_starContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_column_starContext) MULTIPLY_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMULTIPLY_OPERATOR, 0) +} + +func (s *Select_column_starContext) Star_modifiers() IStar_modifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStar_modifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStar_modifiersContext) +} + +func (s *Select_column_starContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_column_starContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_column_starContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSelect_column_star(s) + } +} + +func (s *Select_column_starContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSelect_column_star(s) + } +} + +func (s *Select_column_starContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSelect_column_star(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Select_column_star() (localctx ISelect_column_starContext) { + localctx = NewSelect_column_starContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 938, GoogleSQLParserRULE_select_column_star) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5599) + p.Match(GoogleSQLParserMULTIPLY_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5601) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 709, p.GetParserRuleContext()) == 1 { + { + p.SetState(5600) + p.Star_modifiers() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_column_exprContext is an interface to support dynamic dispatch. +type ISelect_column_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + Select_column_expr_with_as_alias() ISelect_column_expr_with_as_aliasContext + Identifier() IIdentifierContext + + // IsSelect_column_exprContext differentiates from other interfaces. + IsSelect_column_exprContext() +} + +type Select_column_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_column_exprContext() *Select_column_exprContext { + var p = new(Select_column_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_select_column_expr + return p +} + +func InitEmptySelect_column_exprContext(p *Select_column_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_select_column_expr +} + +func (*Select_column_exprContext) IsSelect_column_exprContext() {} + +func NewSelect_column_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_column_exprContext { + var p = new(Select_column_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_select_column_expr + + return p +} + +func (s *Select_column_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_column_exprContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Select_column_exprContext) Select_column_expr_with_as_alias() ISelect_column_expr_with_as_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_column_expr_with_as_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_column_expr_with_as_aliasContext) +} + +func (s *Select_column_exprContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Select_column_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_column_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_column_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSelect_column_expr(s) + } +} + +func (s *Select_column_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSelect_column_expr(s) + } +} + +func (s *Select_column_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSelect_column_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Select_column_expr() (localctx ISelect_column_exprContext) { + localctx = NewSelect_column_exprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 940, GoogleSQLParserRULE_select_column_expr) + p.SetState(5608) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 710, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5603) + p.expression(0) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5604) + p.Select_column_expr_with_as_alias() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5605) + p.expression(0) + } + { + p.SetState(5606) + p.Identifier() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_column_dot_starContext is an interface to support dynamic dispatch. +type ISelect_column_dot_starContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression_higher_prec_than_and() IExpression_higher_prec_than_andContext + DOT_SYMBOL() antlr.TerminalNode + MULTIPLY_OPERATOR() antlr.TerminalNode + Star_modifiers() IStar_modifiersContext + + // IsSelect_column_dot_starContext differentiates from other interfaces. + IsSelect_column_dot_starContext() +} + +type Select_column_dot_starContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_column_dot_starContext() *Select_column_dot_starContext { + var p = new(Select_column_dot_starContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_select_column_dot_star + return p +} + +func InitEmptySelect_column_dot_starContext(p *Select_column_dot_starContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_select_column_dot_star +} + +func (*Select_column_dot_starContext) IsSelect_column_dot_starContext() {} + +func NewSelect_column_dot_starContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_column_dot_starContext { + var p = new(Select_column_dot_starContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_select_column_dot_star + + return p +} + +func (s *Select_column_dot_starContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_column_dot_starContext) Expression_higher_prec_than_and() IExpression_higher_prec_than_andContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_higher_prec_than_andContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpression_higher_prec_than_andContext) +} + +func (s *Select_column_dot_starContext) DOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDOT_SYMBOL, 0) +} + +func (s *Select_column_dot_starContext) MULTIPLY_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMULTIPLY_OPERATOR, 0) +} + +func (s *Select_column_dot_starContext) Star_modifiers() IStar_modifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStar_modifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStar_modifiersContext) +} + +func (s *Select_column_dot_starContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_column_dot_starContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_column_dot_starContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSelect_column_dot_star(s) + } +} + +func (s *Select_column_dot_starContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSelect_column_dot_star(s) + } +} + +func (s *Select_column_dot_starContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSelect_column_dot_star(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Select_column_dot_star() (localctx ISelect_column_dot_starContext) { + localctx = NewSelect_column_dot_starContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 942, GoogleSQLParserRULE_select_column_dot_star) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5610) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5611) + p.Match(GoogleSQLParserDOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5612) + p.Match(GoogleSQLParserMULTIPLY_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5614) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 711, p.GetParserRuleContext()) == 1 { + { + p.SetState(5613) + p.Star_modifiers() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStar_modifiersContext is an interface to support dynamic dispatch. +type IStar_modifiersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Star_except_list() IStar_except_listContext + Star_replace_list() IStar_replace_listContext + + // IsStar_modifiersContext differentiates from other interfaces. + IsStar_modifiersContext() +} + +type Star_modifiersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStar_modifiersContext() *Star_modifiersContext { + var p = new(Star_modifiersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_star_modifiers + return p +} + +func InitEmptyStar_modifiersContext(p *Star_modifiersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_star_modifiers +} + +func (*Star_modifiersContext) IsStar_modifiersContext() {} + +func NewStar_modifiersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Star_modifiersContext { + var p = new(Star_modifiersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_star_modifiers + + return p +} + +func (s *Star_modifiersContext) GetParser() antlr.Parser { return s.parser } + +func (s *Star_modifiersContext) Star_except_list() IStar_except_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStar_except_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStar_except_listContext) +} + +func (s *Star_modifiersContext) Star_replace_list() IStar_replace_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStar_replace_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStar_replace_listContext) +} + +func (s *Star_modifiersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Star_modifiersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Star_modifiersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterStar_modifiers(s) + } +} + +func (s *Star_modifiersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitStar_modifiers(s) + } +} + +func (s *Star_modifiersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitStar_modifiers(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Star_modifiers() (localctx IStar_modifiersContext) { + localctx = NewStar_modifiersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 944, GoogleSQLParserRULE_star_modifiers) + var _la int + + p.SetState(5621) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 713, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5616) + p.Star_except_list() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(5618) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserEXCEPT_SYMBOL { + { + p.SetState(5617) + p.Star_except_list() + } + + } + { + p.SetState(5620) + p.Star_replace_list() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStar_except_listContext is an interface to support dynamic dispatch. +type IStar_except_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXCEPT_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsStar_except_listContext differentiates from other interfaces. + IsStar_except_listContext() +} + +type Star_except_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStar_except_listContext() *Star_except_listContext { + var p = new(Star_except_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_star_except_list + return p +} + +func InitEmptyStar_except_listContext(p *Star_except_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_star_except_list +} + +func (*Star_except_listContext) IsStar_except_listContext() {} + +func NewStar_except_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Star_except_listContext { + var p = new(Star_except_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_star_except_list + + return p +} + +func (s *Star_except_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Star_except_listContext) EXCEPT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXCEPT_SYMBOL, 0) +} + +func (s *Star_except_listContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Star_except_listContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Star_except_listContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Star_except_listContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Star_except_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Star_except_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Star_except_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Star_except_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Star_except_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterStar_except_list(s) + } +} + +func (s *Star_except_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitStar_except_list(s) + } +} + +func (s *Star_except_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitStar_except_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Star_except_list() (localctx IStar_except_listContext) { + localctx = NewStar_except_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 946, GoogleSQLParserRULE_star_except_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5623) + p.Match(GoogleSQLParserEXCEPT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5624) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5625) + p.Identifier() + } + p.SetState(5630) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(5626) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5627) + p.Identifier() + } + + p.SetState(5632) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5633) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStar_replace_listContext is an interface to support dynamic dispatch. +type IStar_replace_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REPLACE_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + AllStar_replace_item() []IStar_replace_itemContext + Star_replace_item(i int) IStar_replace_itemContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsStar_replace_listContext differentiates from other interfaces. + IsStar_replace_listContext() +} + +type Star_replace_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStar_replace_listContext() *Star_replace_listContext { + var p = new(Star_replace_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_star_replace_list + return p +} + +func InitEmptyStar_replace_listContext(p *Star_replace_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_star_replace_list +} + +func (*Star_replace_listContext) IsStar_replace_listContext() {} + +func NewStar_replace_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Star_replace_listContext { + var p = new(Star_replace_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_star_replace_list + + return p +} + +func (s *Star_replace_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Star_replace_listContext) REPLACE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREPLACE_SYMBOL, 0) +} + +func (s *Star_replace_listContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Star_replace_listContext) AllStar_replace_item() []IStar_replace_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStar_replace_itemContext); ok { + len++ + } + } + + tst := make([]IStar_replace_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStar_replace_itemContext); ok { + tst[i] = t.(IStar_replace_itemContext) + i++ + } + } + + return tst +} + +func (s *Star_replace_listContext) Star_replace_item(i int) IStar_replace_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStar_replace_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStar_replace_itemContext) +} + +func (s *Star_replace_listContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Star_replace_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Star_replace_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Star_replace_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Star_replace_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Star_replace_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterStar_replace_list(s) + } +} + +func (s *Star_replace_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitStar_replace_list(s) + } +} + +func (s *Star_replace_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitStar_replace_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Star_replace_list() (localctx IStar_replace_listContext) { + localctx = NewStar_replace_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 948, GoogleSQLParserRULE_star_replace_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5635) + p.Match(GoogleSQLParserREPLACE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5636) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5637) + p.Star_replace_item() + } + p.SetState(5642) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(5638) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5639) + p.Star_replace_item() + } + + p.SetState(5644) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5645) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStar_replace_itemContext is an interface to support dynamic dispatch. +type IStar_replace_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + AS_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsStar_replace_itemContext differentiates from other interfaces. + IsStar_replace_itemContext() +} + +type Star_replace_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStar_replace_itemContext() *Star_replace_itemContext { + var p = new(Star_replace_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_star_replace_item + return p +} + +func InitEmptyStar_replace_itemContext(p *Star_replace_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_star_replace_item +} + +func (*Star_replace_itemContext) IsStar_replace_itemContext() {} + +func NewStar_replace_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Star_replace_itemContext { + var p = new(Star_replace_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_star_replace_item + + return p +} + +func (s *Star_replace_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Star_replace_itemContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Star_replace_itemContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Star_replace_itemContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Star_replace_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Star_replace_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Star_replace_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterStar_replace_item(s) + } +} + +func (s *Star_replace_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitStar_replace_item(s) + } +} + +func (s *Star_replace_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitStar_replace_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Star_replace_item() (localctx IStar_replace_itemContext) { + localctx = NewStar_replace_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 950, GoogleSQLParserRULE_star_replace_item) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5647) + p.expression(0) + } + { + p.SetState(5648) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5649) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpressionContext is an interface to support dynamic dispatch. +type IExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression_higher_prec_than_and() IExpression_higher_prec_than_andContext + And_expression() IAnd_expressionContext + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + OR_SYMBOL() antlr.TerminalNode + + // IsExpressionContext differentiates from other interfaces. + IsExpressionContext() +} + +type ExpressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpressionContext() *ExpressionContext { + var p = new(ExpressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_expression + return p +} + +func InitEmptyExpressionContext(p *ExpressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_expression +} + +func (*ExpressionContext) IsExpressionContext() {} + +func NewExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionContext { + var p = new(ExpressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_expression + + return p +} + +func (s *ExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExpressionContext) Expression_higher_prec_than_and() IExpression_higher_prec_than_andContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_higher_prec_than_andContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpression_higher_prec_than_andContext) +} + +func (s *ExpressionContext) And_expression() IAnd_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnd_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnd_expressionContext) +} + +func (s *ExpressionContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *ExpressionContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ExpressionContext) OR_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOR_SYMBOL, 0) +} + +func (s *ExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterExpression(s) + } +} + +func (s *ExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitExpression(s) + } +} + +func (s *ExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitExpression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Expression() (localctx IExpressionContext) { + return p.expression(0) +} + +func (p *GoogleSQLParser) expression(_p int) (localctx IExpressionContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewExpressionContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IExpressionContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 952 + p.EnterRecursionRule(localctx, 952, GoogleSQLParserRULE_expression, _p) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5654) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 716, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5652) + p.expression_higher_prec_than_and(0) + } + + case 2: + { + p.SetState(5653) + p.And_expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(5661) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 717, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + localctx = NewExpressionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_expression) + p.SetState(5656) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(5657) + p.Match(GoogleSQLParserOR_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5658) + p.expression(2) + } + + } + p.SetState(5663) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 717, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpression_higher_prec_than_andContext is an interface to support dynamic dispatch. +type IExpression_higher_prec_than_andContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Null_literal() INull_literalContext + Boolean_literal() IBoolean_literalContext + String_literal() IString_literalContext + Bytes_literal() IBytes_literalContext + Integer_literal() IInteger_literalContext + Numeric_literal() INumeric_literalContext + Bignumeric_literal() IBignumeric_literalContext + Json_literal() IJson_literalContext + Floating_point_literal() IFloating_point_literalContext + Date_or_time_literal() IDate_or_time_literalContext + Range_literal() IRange_literalContext + Parameter_expression() IParameter_expressionContext + System_variable_expression() ISystem_variable_expressionContext + Array_constructor() IArray_constructorContext + New_constructor() INew_constructorContext + Braced_constructor() IBraced_constructorContext + Braced_new_constructor() IBraced_new_constructorContext + Struct_braced_constructor() IStruct_braced_constructorContext + Case_expression() ICase_expressionContext + Cast_expression() ICast_expressionContext + Extract_expression() IExtract_expressionContext + With_expression() IWith_expressionContext + Replace_fields_expression() IReplace_fields_expressionContext + Function_call_expression_with_clauses() IFunction_call_expression_with_clausesContext + Interval_expression() IInterval_expressionContext + Identifier() IIdentifierContext + Struct_constructor() IStruct_constructorContext + Expression_subquery_with_keyword() IExpression_subquery_with_keywordContext + NOT_SYMBOL() antlr.TerminalNode + AllExpression_higher_prec_than_and() []IExpression_higher_prec_than_andContext + Expression_higher_prec_than_and(i int) IExpression_higher_prec_than_andContext + Unary_operator() IUnary_operatorContext + Parenthesized_expression_not_a_query() IParenthesized_expression_not_a_queryContext + Parenthesized_query() IParenthesized_queryContext + Like_operator() ILike_operatorContext + Distinct_operator() IDistinct_operatorContext + Between_operator() IBetween_operatorContext + AND_SYMBOL() antlr.TerminalNode + Comparative_operator() IComparative_operatorContext + STROKE_SYMBOL() antlr.TerminalNode + CIRCUMFLEX_SYMBOL() antlr.TerminalNode + BIT_AND_SYMBOL() antlr.TerminalNode + BOOL_OR_SYMBOL() antlr.TerminalNode + Shift_operator() IShift_operatorContext + Additive_operator() IAdditive_operatorContext + Multiplicative_operator() IMultiplicative_operatorContext + LS_BRACKET_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + RS_BRACKET_SYMBOL() antlr.TerminalNode + DOT_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + Any_some_all() IAny_some_allContext + Unnest_expression() IUnnest_expressionContext + Hint() IHintContext + Parenthesized_anysomeall_list_in_rhs() IParenthesized_anysomeall_list_in_rhsContext + In_operator() IIn_operatorContext + Parenthesized_in_rhs() IParenthesized_in_rhsContext + OR_SYMBOL() antlr.TerminalNode + Is_operator() IIs_operatorContext + UNKNOWN_SYMBOL() antlr.TerminalNode + + // IsExpression_higher_prec_than_andContext differentiates from other interfaces. + IsExpression_higher_prec_than_andContext() +} + +type Expression_higher_prec_than_andContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpression_higher_prec_than_andContext() *Expression_higher_prec_than_andContext { + var p = new(Expression_higher_prec_than_andContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_expression_higher_prec_than_and + return p +} + +func InitEmptyExpression_higher_prec_than_andContext(p *Expression_higher_prec_than_andContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_expression_higher_prec_than_and +} + +func (*Expression_higher_prec_than_andContext) IsExpression_higher_prec_than_andContext() {} + +func NewExpression_higher_prec_than_andContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expression_higher_prec_than_andContext { + var p = new(Expression_higher_prec_than_andContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_expression_higher_prec_than_and + + return p +} + +func (s *Expression_higher_prec_than_andContext) GetParser() antlr.Parser { return s.parser } + +func (s *Expression_higher_prec_than_andContext) Null_literal() INull_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INull_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INull_literalContext) +} + +func (s *Expression_higher_prec_than_andContext) Boolean_literal() IBoolean_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBoolean_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBoolean_literalContext) +} + +func (s *Expression_higher_prec_than_andContext) String_literal() IString_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_literalContext) +} + +func (s *Expression_higher_prec_than_andContext) Bytes_literal() IBytes_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBytes_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBytes_literalContext) +} + +func (s *Expression_higher_prec_than_andContext) Integer_literal() IInteger_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInteger_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInteger_literalContext) +} + +func (s *Expression_higher_prec_than_andContext) Numeric_literal() INumeric_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumeric_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumeric_literalContext) +} + +func (s *Expression_higher_prec_than_andContext) Bignumeric_literal() IBignumeric_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBignumeric_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBignumeric_literalContext) +} + +func (s *Expression_higher_prec_than_andContext) Json_literal() IJson_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_literalContext) +} + +func (s *Expression_higher_prec_than_andContext) Floating_point_literal() IFloating_point_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFloating_point_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFloating_point_literalContext) +} + +func (s *Expression_higher_prec_than_andContext) Date_or_time_literal() IDate_or_time_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDate_or_time_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDate_or_time_literalContext) +} + +func (s *Expression_higher_prec_than_andContext) Range_literal() IRange_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRange_literalContext) +} + +func (s *Expression_higher_prec_than_andContext) Parameter_expression() IParameter_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameter_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameter_expressionContext) +} + +func (s *Expression_higher_prec_than_andContext) System_variable_expression() ISystem_variable_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISystem_variable_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISystem_variable_expressionContext) +} + +func (s *Expression_higher_prec_than_andContext) Array_constructor() IArray_constructorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArray_constructorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IArray_constructorContext) +} + +func (s *Expression_higher_prec_than_andContext) New_constructor() INew_constructorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INew_constructorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INew_constructorContext) +} + +func (s *Expression_higher_prec_than_andContext) Braced_constructor() IBraced_constructorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBraced_constructorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBraced_constructorContext) +} + +func (s *Expression_higher_prec_than_andContext) Braced_new_constructor() IBraced_new_constructorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBraced_new_constructorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBraced_new_constructorContext) +} + +func (s *Expression_higher_prec_than_andContext) Struct_braced_constructor() IStruct_braced_constructorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStruct_braced_constructorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStruct_braced_constructorContext) +} + +func (s *Expression_higher_prec_than_andContext) Case_expression() ICase_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICase_expressionContext) +} + +func (s *Expression_higher_prec_than_andContext) Cast_expression() ICast_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICast_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICast_expressionContext) +} + +func (s *Expression_higher_prec_than_andContext) Extract_expression() IExtract_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtract_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExtract_expressionContext) +} + +func (s *Expression_higher_prec_than_andContext) With_expression() IWith_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_expressionContext) +} + +func (s *Expression_higher_prec_than_andContext) Replace_fields_expression() IReplace_fields_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReplace_fields_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReplace_fields_expressionContext) +} + +func (s *Expression_higher_prec_than_andContext) Function_call_expression_with_clauses() IFunction_call_expression_with_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_call_expression_with_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_call_expression_with_clausesContext) +} + +func (s *Expression_higher_prec_than_andContext) Interval_expression() IInterval_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInterval_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInterval_expressionContext) +} + +func (s *Expression_higher_prec_than_andContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Expression_higher_prec_than_andContext) Struct_constructor() IStruct_constructorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStruct_constructorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStruct_constructorContext) +} + +func (s *Expression_higher_prec_than_andContext) Expression_subquery_with_keyword() IExpression_subquery_with_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_subquery_with_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpression_subquery_with_keywordContext) +} + +func (s *Expression_higher_prec_than_andContext) NOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNOT_SYMBOL, 0) +} + +func (s *Expression_higher_prec_than_andContext) AllExpression_higher_prec_than_and() []IExpression_higher_prec_than_andContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpression_higher_prec_than_andContext); ok { + len++ + } + } + + tst := make([]IExpression_higher_prec_than_andContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpression_higher_prec_than_andContext); ok { + tst[i] = t.(IExpression_higher_prec_than_andContext) + i++ + } + } + + return tst +} + +func (s *Expression_higher_prec_than_andContext) Expression_higher_prec_than_and(i int) IExpression_higher_prec_than_andContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_higher_prec_than_andContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpression_higher_prec_than_andContext) +} + +func (s *Expression_higher_prec_than_andContext) Unary_operator() IUnary_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnary_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnary_operatorContext) +} + +func (s *Expression_higher_prec_than_andContext) Parenthesized_expression_not_a_query() IParenthesized_expression_not_a_queryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesized_expression_not_a_queryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParenthesized_expression_not_a_queryContext) +} + +func (s *Expression_higher_prec_than_andContext) Parenthesized_query() IParenthesized_queryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesized_queryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParenthesized_queryContext) +} + +func (s *Expression_higher_prec_than_andContext) Like_operator() ILike_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_operatorContext) +} + +func (s *Expression_higher_prec_than_andContext) Distinct_operator() IDistinct_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDistinct_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDistinct_operatorContext) +} + +func (s *Expression_higher_prec_than_andContext) Between_operator() IBetween_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBetween_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBetween_operatorContext) +} + +func (s *Expression_higher_prec_than_andContext) AND_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAND_SYMBOL, 0) +} + +func (s *Expression_higher_prec_than_andContext) Comparative_operator() IComparative_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComparative_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComparative_operatorContext) +} + +func (s *Expression_higher_prec_than_andContext) STROKE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTROKE_SYMBOL, 0) +} + +func (s *Expression_higher_prec_than_andContext) CIRCUMFLEX_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCIRCUMFLEX_SYMBOL, 0) +} + +func (s *Expression_higher_prec_than_andContext) BIT_AND_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBIT_AND_SYMBOL, 0) +} + +func (s *Expression_higher_prec_than_andContext) BOOL_OR_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBOOL_OR_SYMBOL, 0) +} + +func (s *Expression_higher_prec_than_andContext) Shift_operator() IShift_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShift_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShift_operatorContext) +} + +func (s *Expression_higher_prec_than_andContext) Additive_operator() IAdditive_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdditive_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdditive_operatorContext) +} + +func (s *Expression_higher_prec_than_andContext) Multiplicative_operator() IMultiplicative_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultiplicative_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultiplicative_operatorContext) +} + +func (s *Expression_higher_prec_than_andContext) LS_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLS_BRACKET_SYMBOL, 0) +} + +func (s *Expression_higher_prec_than_andContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Expression_higher_prec_than_andContext) RS_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRS_BRACKET_SYMBOL, 0) +} + +func (s *Expression_higher_prec_than_andContext) DOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDOT_SYMBOL, 0) +} + +func (s *Expression_higher_prec_than_andContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Expression_higher_prec_than_andContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Expression_higher_prec_than_andContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Expression_higher_prec_than_andContext) Any_some_all() IAny_some_allContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_some_allContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_some_allContext) +} + +func (s *Expression_higher_prec_than_andContext) Unnest_expression() IUnnest_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnnest_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnnest_expressionContext) +} + +func (s *Expression_higher_prec_than_andContext) Hint() IHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Expression_higher_prec_than_andContext) Parenthesized_anysomeall_list_in_rhs() IParenthesized_anysomeall_list_in_rhsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesized_anysomeall_list_in_rhsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParenthesized_anysomeall_list_in_rhsContext) +} + +func (s *Expression_higher_prec_than_andContext) In_operator() IIn_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIn_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIn_operatorContext) +} + +func (s *Expression_higher_prec_than_andContext) Parenthesized_in_rhs() IParenthesized_in_rhsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesized_in_rhsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParenthesized_in_rhsContext) +} + +func (s *Expression_higher_prec_than_andContext) OR_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOR_SYMBOL, 0) +} + +func (s *Expression_higher_prec_than_andContext) Is_operator() IIs_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIs_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIs_operatorContext) +} + +func (s *Expression_higher_prec_than_andContext) UNKNOWN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUNKNOWN_SYMBOL, 0) +} + +func (s *Expression_higher_prec_than_andContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Expression_higher_prec_than_andContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Expression_higher_prec_than_andContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterExpression_higher_prec_than_and(s) + } +} + +func (s *Expression_higher_prec_than_andContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitExpression_higher_prec_than_and(s) + } +} + +func (s *Expression_higher_prec_than_andContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitExpression_higher_prec_than_and(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Expression_higher_prec_than_and() (localctx IExpression_higher_prec_than_andContext) { + return p.expression_higher_prec_than_and(0) +} + +func (p *GoogleSQLParser) expression_higher_prec_than_and(_p int) (localctx IExpression_higher_prec_than_andContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewExpression_higher_prec_than_andContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IExpression_higher_prec_than_andContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 954 + p.EnterRecursionRule(localctx, 954, GoogleSQLParserRULE_expression_higher_prec_than_and, _p) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5700) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 718, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5665) + p.Null_literal() + } + + case 2: + { + p.SetState(5666) + p.Boolean_literal() + } + + case 3: + { + p.SetState(5667) + p.string_literal(0) + } + + case 4: + { + p.SetState(5668) + p.bytes_literal(0) + } + + case 5: + { + p.SetState(5669) + p.Integer_literal() + } + + case 6: + { + p.SetState(5670) + p.Numeric_literal() + } + + case 7: + { + p.SetState(5671) + p.Bignumeric_literal() + } + + case 8: + { + p.SetState(5672) + p.Json_literal() + } + + case 9: + { + p.SetState(5673) + p.Floating_point_literal() + } + + case 10: + { + p.SetState(5674) + p.Date_or_time_literal() + } + + case 11: + { + p.SetState(5675) + p.Range_literal() + } + + case 12: + { + p.SetState(5676) + p.Parameter_expression() + } + + case 13: + { + p.SetState(5677) + p.System_variable_expression() + } + + case 14: + { + p.SetState(5678) + p.Array_constructor() + } + + case 15: + { + p.SetState(5679) + p.New_constructor() + } + + case 16: + { + p.SetState(5680) + p.Braced_constructor() + } + + case 17: + { + p.SetState(5681) + p.Braced_new_constructor() + } + + case 18: + { + p.SetState(5682) + p.Struct_braced_constructor() + } + + case 19: + { + p.SetState(5683) + p.Case_expression() + } + + case 20: + { + p.SetState(5684) + p.Cast_expression() + } + + case 21: + { + p.SetState(5685) + p.Extract_expression() + } + + case 22: + { + p.SetState(5686) + p.With_expression() + } + + case 23: + { + p.SetState(5687) + p.Replace_fields_expression() + } + + case 24: + { + p.SetState(5688) + p.Function_call_expression_with_clauses() + } + + case 25: + { + p.SetState(5689) + p.Interval_expression() + } + + case 26: + { + p.SetState(5690) + p.Identifier() + } + + case 27: + { + p.SetState(5691) + p.Struct_constructor() + } + + case 28: + { + p.SetState(5692) + p.Expression_subquery_with_keyword() + } + + case 29: + { + p.SetState(5693) + p.Match(GoogleSQLParserNOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5694) + p.expression_higher_prec_than_and(23) + } + + case 30: + { + p.SetState(5695) + p.Unary_operator() + } + { + p.SetState(5696) + p.expression_higher_prec_than_and(3) + } + + case 31: + { + p.SetState(5698) + p.Parenthesized_expression_not_a_query() + } + + case 32: + { + p.SetState(5699) + p.Parenthesized_query() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(5809) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 724, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + p.SetState(5807) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 723, p.GetParserRuleContext()) { + case 1: + localctx = NewExpression_higher_prec_than_andContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_expression_higher_prec_than_and) + p.SetState(5702) + + if !(p.Precpred(p.GetParserRuleContext(), 20)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 20)", "")) + goto errorExit + } + { + p.SetState(5703) + p.Like_operator() + } + { + p.SetState(5704) + p.expression_higher_prec_than_and(21) + } + + case 2: + localctx = NewExpression_higher_prec_than_andContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_expression_higher_prec_than_and) + p.SetState(5706) + + if !(p.Precpred(p.GetParserRuleContext(), 19)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 19)", "")) + goto errorExit + } + { + p.SetState(5707) + p.Distinct_operator() + } + { + p.SetState(5708) + p.expression_higher_prec_than_and(20) + } + + case 3: + localctx = NewExpression_higher_prec_than_andContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_expression_higher_prec_than_and) + p.SetState(5710) + + if !(p.Precpred(p.GetParserRuleContext(), 16)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 16)", "")) + goto errorExit + } + { + p.SetState(5711) + p.Between_operator() + } + { + p.SetState(5712) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5713) + p.Match(GoogleSQLParserAND_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5714) + p.expression_higher_prec_than_and(17) + } + + case 4: + localctx = NewExpression_higher_prec_than_andContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_expression_higher_prec_than_and) + p.SetState(5716) + + if !(p.Precpred(p.GetParserRuleContext(), 11)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 11)", "")) + goto errorExit + } + { + p.SetState(5717) + p.Comparative_operator() + } + { + p.SetState(5718) + p.expression_higher_prec_than_and(12) + } + + case 5: + localctx = NewExpression_higher_prec_than_andContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_expression_higher_prec_than_and) + p.SetState(5720) + + if !(p.Precpred(p.GetParserRuleContext(), 10)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 10)", "")) + goto errorExit + } + { + p.SetState(5721) + p.Match(GoogleSQLParserSTROKE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5722) + p.expression_higher_prec_than_and(11) + } + + case 6: + localctx = NewExpression_higher_prec_than_andContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_expression_higher_prec_than_and) + p.SetState(5723) + + if !(p.Precpred(p.GetParserRuleContext(), 9)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 9)", "")) + goto errorExit + } + { + p.SetState(5724) + p.Match(GoogleSQLParserCIRCUMFLEX_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5725) + p.expression_higher_prec_than_and(10) + } + + case 7: + localctx = NewExpression_higher_prec_than_andContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_expression_higher_prec_than_and) + p.SetState(5726) + + if !(p.Precpred(p.GetParserRuleContext(), 8)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 8)", "")) + goto errorExit + } + { + p.SetState(5727) + p.Match(GoogleSQLParserBIT_AND_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5728) + p.expression_higher_prec_than_and(9) + } + + case 8: + localctx = NewExpression_higher_prec_than_andContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_expression_higher_prec_than_and) + p.SetState(5729) + + if !(p.Precpred(p.GetParserRuleContext(), 7)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 7)", "")) + goto errorExit + } + { + p.SetState(5730) + p.Match(GoogleSQLParserBOOL_OR_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5731) + p.expression_higher_prec_than_and(8) + } + + case 9: + localctx = NewExpression_higher_prec_than_andContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_expression_higher_prec_than_and) + p.SetState(5732) + + if !(p.Precpred(p.GetParserRuleContext(), 6)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 6)", "")) + goto errorExit + } + { + p.SetState(5733) + p.Shift_operator() + } + { + p.SetState(5734) + p.expression_higher_prec_than_and(7) + } + + case 10: + localctx = NewExpression_higher_prec_than_andContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_expression_higher_prec_than_and) + p.SetState(5736) + + if !(p.Precpred(p.GetParserRuleContext(), 5)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", "")) + goto errorExit + } + { + p.SetState(5737) + p.Additive_operator() + } + { + p.SetState(5738) + p.expression_higher_prec_than_and(6) + } + + case 11: + localctx = NewExpression_higher_prec_than_andContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_expression_higher_prec_than_and) + p.SetState(5740) + + if !(p.Precpred(p.GetParserRuleContext(), 4)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", "")) + goto errorExit + } + { + p.SetState(5741) + p.Multiplicative_operator() + } + { + p.SetState(5742) + p.expression_higher_prec_than_and(5) + } + + case 12: + localctx = NewExpression_higher_prec_than_andContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_expression_higher_prec_than_and) + p.SetState(5744) + + if !(p.Precpred(p.GetParserRuleContext(), 26)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 26)", "")) + goto errorExit + } + { + p.SetState(5745) + p.Match(GoogleSQLParserLS_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5746) + p.expression(0) + } + { + p.SetState(5747) + p.Match(GoogleSQLParserRS_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + localctx = NewExpression_higher_prec_than_andContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_expression_higher_prec_than_and) + p.SetState(5749) + + if !(p.Precpred(p.GetParserRuleContext(), 25)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 25)", "")) + goto errorExit + } + { + p.SetState(5750) + p.Match(GoogleSQLParserDOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5751) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5752) + p.Path_expression() + } + { + p.SetState(5753) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + localctx = NewExpression_higher_prec_than_andContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_expression_higher_prec_than_and) + p.SetState(5755) + + if !(p.Precpred(p.GetParserRuleContext(), 24)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 24)", "")) + goto errorExit + } + { + p.SetState(5756) + p.Match(GoogleSQLParserDOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5757) + p.Identifier() + } + + case 15: + localctx = NewExpression_higher_prec_than_andContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_expression_higher_prec_than_and) + p.SetState(5758) + + if !(p.Precpred(p.GetParserRuleContext(), 22)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 22)", "")) + goto errorExit + } + { + p.SetState(5759) + p.Like_operator() + } + { + p.SetState(5760) + p.Any_some_all() + } + p.SetState(5762) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(5761) + p.Hint() + } + + } + { + p.SetState(5764) + p.Unnest_expression() + } + + case 16: + localctx = NewExpression_higher_prec_than_andContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_expression_higher_prec_than_and) + p.SetState(5766) + + if !(p.Precpred(p.GetParserRuleContext(), 21)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 21)", "")) + goto errorExit + } + { + p.SetState(5767) + p.Like_operator() + } + { + p.SetState(5768) + p.Any_some_all() + } + p.SetState(5770) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(5769) + p.Hint() + } + + } + { + p.SetState(5772) + p.Parenthesized_anysomeall_list_in_rhs() + } + + case 17: + localctx = NewExpression_higher_prec_than_andContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_expression_higher_prec_than_and) + p.SetState(5774) + + if !(p.Precpred(p.GetParserRuleContext(), 18)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 18)", "")) + goto errorExit + } + { + p.SetState(5775) + p.In_operator() + } + p.SetState(5777) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(5776) + p.Hint() + } + + } + { + p.SetState(5779) + p.Unnest_expression() + } + + if localctx.Hint() != nil { + p.NotifyErrorListeners("Syntax error: HINTs cannot be specified on IN clause with UNNEST", nil, nil) + } + + case 18: + localctx = NewExpression_higher_prec_than_andContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_expression_higher_prec_than_and) + p.SetState(5782) + + if !(p.Precpred(p.GetParserRuleContext(), 17)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 17)", "")) + goto errorExit + } + { + p.SetState(5783) + p.In_operator() + } + p.SetState(5785) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(5784) + p.Hint() + } + + } + { + p.SetState(5787) + p.Parenthesized_in_rhs() + } + + case 19: + localctx = NewExpression_higher_prec_than_andContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_expression_higher_prec_than_and) + p.SetState(5789) + + if !(p.Precpred(p.GetParserRuleContext(), 15)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 15)", "")) + goto errorExit + } + { + p.SetState(5790) + p.Between_operator() + } + { + p.SetState(5791) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5792) + p.Match(GoogleSQLParserOR_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.NotifyErrorListeners("Syntax error: Expression in BETWEEN must be parenthesized", nil, nil) + + case 20: + localctx = NewExpression_higher_prec_than_andContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_expression_higher_prec_than_and) + p.SetState(5795) + + if !(p.Precpred(p.GetParserRuleContext(), 14)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 14)", "")) + goto errorExit + } + { + p.SetState(5796) + p.Is_operator() + } + { + p.SetState(5797) + p.Match(GoogleSQLParserUNKNOWN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 21: + localctx = NewExpression_higher_prec_than_andContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_expression_higher_prec_than_and) + p.SetState(5799) + + if !(p.Precpred(p.GetParserRuleContext(), 13)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 13)", "")) + goto errorExit + } + { + p.SetState(5800) + p.Is_operator() + } + { + p.SetState(5801) + p.Null_literal() + } + + case 22: + localctx = NewExpression_higher_prec_than_andContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_expression_higher_prec_than_and) + p.SetState(5803) + + if !(p.Precpred(p.GetParserRuleContext(), 12)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 12)", "")) + goto errorExit + } + { + p.SetState(5804) + p.Is_operator() + } + { + p.SetState(5805) + p.Boolean_literal() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(5811) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 724, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpression_maybe_parenthesized_not_a_queryContext is an interface to support dynamic dispatch. +type IExpression_maybe_parenthesized_not_a_queryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Parenthesized_expression_not_a_query() IParenthesized_expression_not_a_queryContext + Null_literal() INull_literalContext + Boolean_literal() IBoolean_literalContext + String_literal() IString_literalContext + Bytes_literal() IBytes_literalContext + Integer_literal() IInteger_literalContext + Numeric_literal() INumeric_literalContext + Bignumeric_literal() IBignumeric_literalContext + Json_literal() IJson_literalContext + Floating_point_literal() IFloating_point_literalContext + Date_or_time_literal() IDate_or_time_literalContext + Range_literal() IRange_literalContext + Parameter_expression() IParameter_expressionContext + System_variable_expression() ISystem_variable_expressionContext + Array_constructor() IArray_constructorContext + New_constructor() INew_constructorContext + Braced_constructor() IBraced_constructorContext + Braced_new_constructor() IBraced_new_constructorContext + Struct_braced_constructor() IStruct_braced_constructorContext + Case_expression() ICase_expressionContext + Cast_expression() ICast_expressionContext + Extract_expression() IExtract_expressionContext + With_expression() IWith_expressionContext + Replace_fields_expression() IReplace_fields_expressionContext + Function_call_expression_with_clauses() IFunction_call_expression_with_clausesContext + Interval_expression() IInterval_expressionContext + Identifier() IIdentifierContext + Struct_constructor() IStruct_constructorContext + Expression_subquery_with_keyword() IExpression_subquery_with_keywordContext + AllExpression_higher_prec_than_and() []IExpression_higher_prec_than_andContext + Expression_higher_prec_than_and(i int) IExpression_higher_prec_than_andContext + LS_BRACKET_SYMBOL() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + RS_BRACKET_SYMBOL() antlr.TerminalNode + DOT_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + NOT_SYMBOL() antlr.TerminalNode + Like_operator() ILike_operatorContext + Any_some_all() IAny_some_allContext + Unnest_expression() IUnnest_expressionContext + Hint() IHintContext + Parenthesized_anysomeall_list_in_rhs() IParenthesized_anysomeall_list_in_rhsContext + Distinct_operator() IDistinct_operatorContext + In_operator() IIn_operatorContext + Parenthesized_in_rhs() IParenthesized_in_rhsContext + Between_operator() IBetween_operatorContext + AND_SYMBOL() antlr.TerminalNode + OR_SYMBOL() antlr.TerminalNode + Is_operator() IIs_operatorContext + UNKNOWN_SYMBOL() antlr.TerminalNode + Comparative_operator() IComparative_operatorContext + STROKE_SYMBOL() antlr.TerminalNode + CIRCUMFLEX_SYMBOL() antlr.TerminalNode + BIT_AND_SYMBOL() antlr.TerminalNode + BOOL_OR_SYMBOL() antlr.TerminalNode + Shift_operator() IShift_operatorContext + Additive_operator() IAdditive_operatorContext + Multiplicative_operator() IMultiplicative_operatorContext + Unary_operator() IUnary_operatorContext + And_expression() IAnd_expressionContext + + // IsExpression_maybe_parenthesized_not_a_queryContext differentiates from other interfaces. + IsExpression_maybe_parenthesized_not_a_queryContext() +} + +type Expression_maybe_parenthesized_not_a_queryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpression_maybe_parenthesized_not_a_queryContext() *Expression_maybe_parenthesized_not_a_queryContext { + var p = new(Expression_maybe_parenthesized_not_a_queryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_expression_maybe_parenthesized_not_a_query + return p +} + +func InitEmptyExpression_maybe_parenthesized_not_a_queryContext(p *Expression_maybe_parenthesized_not_a_queryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_expression_maybe_parenthesized_not_a_query +} + +func (*Expression_maybe_parenthesized_not_a_queryContext) IsExpression_maybe_parenthesized_not_a_queryContext() { +} + +func NewExpression_maybe_parenthesized_not_a_queryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expression_maybe_parenthesized_not_a_queryContext { + var p = new(Expression_maybe_parenthesized_not_a_queryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_expression_maybe_parenthesized_not_a_query + + return p +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Parenthesized_expression_not_a_query() IParenthesized_expression_not_a_queryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesized_expression_not_a_queryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParenthesized_expression_not_a_queryContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Null_literal() INull_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INull_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INull_literalContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Boolean_literal() IBoolean_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBoolean_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBoolean_literalContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) String_literal() IString_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_literalContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Bytes_literal() IBytes_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBytes_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBytes_literalContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Integer_literal() IInteger_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInteger_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInteger_literalContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Numeric_literal() INumeric_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumeric_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumeric_literalContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Bignumeric_literal() IBignumeric_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBignumeric_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBignumeric_literalContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Json_literal() IJson_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_literalContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Floating_point_literal() IFloating_point_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFloating_point_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFloating_point_literalContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Date_or_time_literal() IDate_or_time_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDate_or_time_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDate_or_time_literalContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Range_literal() IRange_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRange_literalContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Parameter_expression() IParameter_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameter_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameter_expressionContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) System_variable_expression() ISystem_variable_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISystem_variable_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISystem_variable_expressionContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Array_constructor() IArray_constructorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArray_constructorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IArray_constructorContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) New_constructor() INew_constructorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INew_constructorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INew_constructorContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Braced_constructor() IBraced_constructorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBraced_constructorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBraced_constructorContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Braced_new_constructor() IBraced_new_constructorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBraced_new_constructorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBraced_new_constructorContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Struct_braced_constructor() IStruct_braced_constructorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStruct_braced_constructorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStruct_braced_constructorContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Case_expression() ICase_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICase_expressionContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Cast_expression() ICast_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICast_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICast_expressionContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Extract_expression() IExtract_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtract_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExtract_expressionContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) With_expression() IWith_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_expressionContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Replace_fields_expression() IReplace_fields_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReplace_fields_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReplace_fields_expressionContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Function_call_expression_with_clauses() IFunction_call_expression_with_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_call_expression_with_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_call_expression_with_clausesContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Interval_expression() IInterval_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInterval_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInterval_expressionContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Struct_constructor() IStruct_constructorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStruct_constructorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStruct_constructorContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Expression_subquery_with_keyword() IExpression_subquery_with_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_subquery_with_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpression_subquery_with_keywordContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) AllExpression_higher_prec_than_and() []IExpression_higher_prec_than_andContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpression_higher_prec_than_andContext); ok { + len++ + } + } + + tst := make([]IExpression_higher_prec_than_andContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpression_higher_prec_than_andContext); ok { + tst[i] = t.(IExpression_higher_prec_than_andContext) + i++ + } + } + + return tst +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Expression_higher_prec_than_and(i int) IExpression_higher_prec_than_andContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_higher_prec_than_andContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpression_higher_prec_than_andContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) LS_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLS_BRACKET_SYMBOL, 0) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) RS_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRS_BRACKET_SYMBOL, 0) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) DOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDOT_SYMBOL, 0) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) NOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNOT_SYMBOL, 0) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Like_operator() ILike_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_operatorContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Any_some_all() IAny_some_allContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_some_allContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_some_allContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Unnest_expression() IUnnest_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnnest_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnnest_expressionContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Hint() IHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Parenthesized_anysomeall_list_in_rhs() IParenthesized_anysomeall_list_in_rhsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesized_anysomeall_list_in_rhsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParenthesized_anysomeall_list_in_rhsContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Distinct_operator() IDistinct_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDistinct_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDistinct_operatorContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) In_operator() IIn_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIn_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIn_operatorContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Parenthesized_in_rhs() IParenthesized_in_rhsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesized_in_rhsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParenthesized_in_rhsContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Between_operator() IBetween_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBetween_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBetween_operatorContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) AND_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAND_SYMBOL, 0) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) OR_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOR_SYMBOL, 0) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Is_operator() IIs_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIs_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIs_operatorContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) UNKNOWN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUNKNOWN_SYMBOL, 0) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Comparative_operator() IComparative_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComparative_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComparative_operatorContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) STROKE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTROKE_SYMBOL, 0) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) CIRCUMFLEX_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCIRCUMFLEX_SYMBOL, 0) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) BIT_AND_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBIT_AND_SYMBOL, 0) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) BOOL_OR_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBOOL_OR_SYMBOL, 0) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Shift_operator() IShift_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShift_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShift_operatorContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Additive_operator() IAdditive_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdditive_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdditive_operatorContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Multiplicative_operator() IMultiplicative_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultiplicative_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultiplicative_operatorContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Unary_operator() IUnary_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnary_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnary_operatorContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) And_expression() IAnd_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnd_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnd_expressionContext) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterExpression_maybe_parenthesized_not_a_query(s) + } +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitExpression_maybe_parenthesized_not_a_query(s) + } +} + +func (s *Expression_maybe_parenthesized_not_a_queryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitExpression_maybe_parenthesized_not_a_query(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Expression_maybe_parenthesized_not_a_query() (localctx IExpression_maybe_parenthesized_not_a_queryContext) { + localctx = NewExpression_maybe_parenthesized_not_a_queryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 956, GoogleSQLParserRULE_expression_maybe_parenthesized_not_a_query) + var _la int + + p.SetState(5961) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 729, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5812) + p.Parenthesized_expression_not_a_query() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5813) + p.Null_literal() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5814) + p.Boolean_literal() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5815) + p.string_literal(0) + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5816) + p.bytes_literal(0) + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5817) + p.Integer_literal() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(5818) + p.Numeric_literal() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(5819) + p.Bignumeric_literal() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(5820) + p.Json_literal() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(5821) + p.Floating_point_literal() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(5822) + p.Date_or_time_literal() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(5823) + p.Range_literal() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(5824) + p.Parameter_expression() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(5825) + p.System_variable_expression() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(5826) + p.Array_constructor() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(5827) + p.New_constructor() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(5828) + p.Braced_constructor() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(5829) + p.Braced_new_constructor() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(5830) + p.Struct_braced_constructor() + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(5831) + p.Case_expression() + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(5832) + p.Cast_expression() + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(5833) + p.Extract_expression() + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(5834) + p.With_expression() + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(5835) + p.Replace_fields_expression() + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(5836) + p.Function_call_expression_with_clauses() + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(5837) + p.Interval_expression() + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(5838) + p.Identifier() + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(5839) + p.Struct_constructor() + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(5840) + p.Expression_subquery_with_keyword() + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(5841) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5842) + p.Match(GoogleSQLParserLS_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5843) + p.expression(0) + } + { + p.SetState(5844) + p.Match(GoogleSQLParserRS_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 31: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(5846) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5847) + p.Match(GoogleSQLParserDOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5848) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5849) + p.Path_expression() + } + { + p.SetState(5850) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 32: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(5852) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5853) + p.Match(GoogleSQLParserDOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5854) + p.Identifier() + } + + case 33: + p.EnterOuterAlt(localctx, 33) + { + p.SetState(5856) + p.Match(GoogleSQLParserNOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5857) + p.expression_higher_prec_than_and(0) + } + + case 34: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(5858) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5859) + p.Like_operator() + } + { + p.SetState(5860) + p.Any_some_all() + } + p.SetState(5862) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(5861) + p.Hint() + } + + } + { + p.SetState(5864) + p.Unnest_expression() + } + + case 35: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(5866) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5867) + p.Like_operator() + } + { + p.SetState(5868) + p.Any_some_all() + } + p.SetState(5870) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(5869) + p.Hint() + } + + } + { + p.SetState(5872) + p.Parenthesized_anysomeall_list_in_rhs() + } + + case 36: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(5874) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5875) + p.Like_operator() + } + { + p.SetState(5876) + p.expression_higher_prec_than_and(0) + } + + case 37: + p.EnterOuterAlt(localctx, 37) + { + p.SetState(5878) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5879) + p.Distinct_operator() + } + { + p.SetState(5880) + p.expression_higher_prec_than_and(0) + } + + case 38: + p.EnterOuterAlt(localctx, 38) + { + p.SetState(5882) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5883) + p.In_operator() + } + p.SetState(5885) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(5884) + p.Hint() + } + + } + { + p.SetState(5887) + p.Unnest_expression() + } + + if localctx.Hint() != nil { + p.NotifyErrorListeners("Syntax error: HINTs cannot be specified on IN clause with UNNEST", nil, nil) + } + + case 39: + p.EnterOuterAlt(localctx, 39) + { + p.SetState(5890) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5891) + p.In_operator() + } + p.SetState(5893) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(5892) + p.Hint() + } + + } + { + p.SetState(5895) + p.Parenthesized_in_rhs() + } + + case 40: + p.EnterOuterAlt(localctx, 40) + { + p.SetState(5897) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5898) + p.Between_operator() + } + { + p.SetState(5899) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5900) + p.Match(GoogleSQLParserAND_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5901) + p.expression_higher_prec_than_and(0) + } + + case 41: + p.EnterOuterAlt(localctx, 41) + { + p.SetState(5903) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5904) + p.Between_operator() + } + { + p.SetState(5905) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5906) + p.Match(GoogleSQLParserOR_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.NotifyErrorListeners("Syntax error: Expression in BETWEEN must be parenthesized", nil, nil) + + case 42: + p.EnterOuterAlt(localctx, 42) + { + p.SetState(5909) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5910) + p.Is_operator() + } + { + p.SetState(5911) + p.Match(GoogleSQLParserUNKNOWN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 43: + p.EnterOuterAlt(localctx, 43) + { + p.SetState(5913) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5914) + p.Is_operator() + } + { + p.SetState(5915) + p.Null_literal() + } + + case 44: + p.EnterOuterAlt(localctx, 44) + { + p.SetState(5917) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5918) + p.Is_operator() + } + { + p.SetState(5919) + p.Boolean_literal() + } + + case 45: + p.EnterOuterAlt(localctx, 45) + { + p.SetState(5921) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5922) + p.Comparative_operator() + } + { + p.SetState(5923) + p.expression_higher_prec_than_and(0) + } + + case 46: + p.EnterOuterAlt(localctx, 46) + { + p.SetState(5925) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5926) + p.Match(GoogleSQLParserSTROKE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5927) + p.expression_higher_prec_than_and(0) + } + + case 47: + p.EnterOuterAlt(localctx, 47) + { + p.SetState(5929) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5930) + p.Match(GoogleSQLParserCIRCUMFLEX_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5931) + p.expression_higher_prec_than_and(0) + } + + case 48: + p.EnterOuterAlt(localctx, 48) + { + p.SetState(5933) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5934) + p.Match(GoogleSQLParserBIT_AND_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5935) + p.expression_higher_prec_than_and(0) + } + + case 49: + p.EnterOuterAlt(localctx, 49) + { + p.SetState(5937) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5938) + p.Match(GoogleSQLParserBOOL_OR_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5939) + p.expression_higher_prec_than_and(0) + } + + case 50: + p.EnterOuterAlt(localctx, 50) + { + p.SetState(5941) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5942) + p.Shift_operator() + } + { + p.SetState(5943) + p.expression_higher_prec_than_and(0) + } + + case 51: + p.EnterOuterAlt(localctx, 51) + { + p.SetState(5945) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5946) + p.Additive_operator() + } + { + p.SetState(5947) + p.expression_higher_prec_than_and(0) + } + + case 52: + p.EnterOuterAlt(localctx, 52) + { + p.SetState(5949) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(5950) + p.Multiplicative_operator() + } + { + p.SetState(5951) + p.expression_higher_prec_than_and(0) + } + + case 53: + p.EnterOuterAlt(localctx, 53) + { + p.SetState(5953) + p.Unary_operator() + } + { + p.SetState(5954) + p.expression_higher_prec_than_and(0) + } + + case 54: + p.EnterOuterAlt(localctx, 54) + { + p.SetState(5956) + p.And_expression() + } + + case 55: + p.EnterOuterAlt(localctx, 55) + { + p.SetState(5957) + p.expression(0) + } + { + p.SetState(5958) + p.Match(GoogleSQLParserOR_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5959) + p.expression(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParenthesized_in_rhsContext is an interface to support dynamic dispatch. +type IParenthesized_in_rhsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Parenthesized_query() IParenthesized_queryContext + LR_BRACKET_SYMBOL() antlr.TerminalNode + Expression_maybe_parenthesized_not_a_query() IExpression_maybe_parenthesized_not_a_queryContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + In_list_two_or_more_prefix() IIn_list_two_or_more_prefixContext + + // IsParenthesized_in_rhsContext differentiates from other interfaces. + IsParenthesized_in_rhsContext() +} + +type Parenthesized_in_rhsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParenthesized_in_rhsContext() *Parenthesized_in_rhsContext { + var p = new(Parenthesized_in_rhsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_parenthesized_in_rhs + return p +} + +func InitEmptyParenthesized_in_rhsContext(p *Parenthesized_in_rhsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_parenthesized_in_rhs +} + +func (*Parenthesized_in_rhsContext) IsParenthesized_in_rhsContext() {} + +func NewParenthesized_in_rhsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Parenthesized_in_rhsContext { + var p = new(Parenthesized_in_rhsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_parenthesized_in_rhs + + return p +} + +func (s *Parenthesized_in_rhsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Parenthesized_in_rhsContext) Parenthesized_query() IParenthesized_queryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesized_queryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParenthesized_queryContext) +} + +func (s *Parenthesized_in_rhsContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Parenthesized_in_rhsContext) Expression_maybe_parenthesized_not_a_query() IExpression_maybe_parenthesized_not_a_queryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_maybe_parenthesized_not_a_queryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpression_maybe_parenthesized_not_a_queryContext) +} + +func (s *Parenthesized_in_rhsContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Parenthesized_in_rhsContext) In_list_two_or_more_prefix() IIn_list_two_or_more_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIn_list_two_or_more_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIn_list_two_or_more_prefixContext) +} + +func (s *Parenthesized_in_rhsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Parenthesized_in_rhsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Parenthesized_in_rhsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterParenthesized_in_rhs(s) + } +} + +func (s *Parenthesized_in_rhsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitParenthesized_in_rhs(s) + } +} + +func (s *Parenthesized_in_rhsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitParenthesized_in_rhs(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Parenthesized_in_rhs() (localctx IParenthesized_in_rhsContext) { + localctx = NewParenthesized_in_rhsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 958, GoogleSQLParserRULE_parenthesized_in_rhs) + p.SetState(5971) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 730, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5963) + p.Parenthesized_query() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5964) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5965) + p.Expression_maybe_parenthesized_not_a_query() + } + { + p.SetState(5966) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5968) + p.In_list_two_or_more_prefix() + } + { + p.SetState(5969) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnary_operatorContext is an interface to support dynamic dispatch. +type IUnary_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PLUS_OPERATOR() antlr.TerminalNode + MINUS_OPERATOR() antlr.TerminalNode + BITWISE_NOT_OPERATOR() antlr.TerminalNode + + // IsUnary_operatorContext differentiates from other interfaces. + IsUnary_operatorContext() +} + +type Unary_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnary_operatorContext() *Unary_operatorContext { + var p = new(Unary_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unary_operator + return p +} + +func InitEmptyUnary_operatorContext(p *Unary_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_unary_operator +} + +func (*Unary_operatorContext) IsUnary_operatorContext() {} + +func NewUnary_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unary_operatorContext { + var p = new(Unary_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_unary_operator + + return p +} + +func (s *Unary_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unary_operatorContext) PLUS_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPLUS_OPERATOR, 0) +} + +func (s *Unary_operatorContext) MINUS_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMINUS_OPERATOR, 0) +} + +func (s *Unary_operatorContext) BITWISE_NOT_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBITWISE_NOT_OPERATOR, 0) +} + +func (s *Unary_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unary_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unary_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterUnary_operator(s) + } +} + +func (s *Unary_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitUnary_operator(s) + } +} + +func (s *Unary_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitUnary_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Unary_operator() (localctx IUnary_operatorContext) { + localctx = NewUnary_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 960, GoogleSQLParserRULE_unary_operator) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5973) + _la = p.GetTokenStream().LA(1) + + if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&19456) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IComparative_operatorContext is an interface to support dynamic dispatch. +type IComparative_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EQUAL_OPERATOR() antlr.TerminalNode + NOT_EQUAL_OPERATOR() antlr.TerminalNode + NOT_EQUAL2_OPERATOR() antlr.TerminalNode + LT_OPERATOR() antlr.TerminalNode + LE_OPERATOR() antlr.TerminalNode + GT_OPERATOR() antlr.TerminalNode + GE_OPERATOR() antlr.TerminalNode + + // IsComparative_operatorContext differentiates from other interfaces. + IsComparative_operatorContext() +} + +type Comparative_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComparative_operatorContext() *Comparative_operatorContext { + var p = new(Comparative_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_comparative_operator + return p +} + +func InitEmptyComparative_operatorContext(p *Comparative_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_comparative_operator +} + +func (*Comparative_operatorContext) IsComparative_operatorContext() {} + +func NewComparative_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Comparative_operatorContext { + var p = new(Comparative_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_comparative_operator + + return p +} + +func (s *Comparative_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Comparative_operatorContext) EQUAL_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEQUAL_OPERATOR, 0) +} + +func (s *Comparative_operatorContext) NOT_EQUAL_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNOT_EQUAL_OPERATOR, 0) +} + +func (s *Comparative_operatorContext) NOT_EQUAL2_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNOT_EQUAL2_OPERATOR, 0) +} + +func (s *Comparative_operatorContext) LT_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLT_OPERATOR, 0) +} + +func (s *Comparative_operatorContext) LE_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLE_OPERATOR, 0) +} + +func (s *Comparative_operatorContext) GT_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserGT_OPERATOR, 0) +} + +func (s *Comparative_operatorContext) GE_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserGE_OPERATOR, 0) +} + +func (s *Comparative_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Comparative_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Comparative_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterComparative_operator(s) + } +} + +func (s *Comparative_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitComparative_operator(s) + } +} + +func (s *Comparative_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitComparative_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Comparative_operator() (localctx IComparative_operatorContext) { + localctx = NewComparative_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 962, GoogleSQLParserRULE_comparative_operator) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5975) + _la = p.GetTokenStream().LA(1) + + if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&254) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShift_operatorContext is an interface to support dynamic dispatch. +type IShift_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KL_OPERATOR() antlr.TerminalNode + KR_OPERATOR() antlr.TerminalNode + + // IsShift_operatorContext differentiates from other interfaces. + IsShift_operatorContext() +} + +type Shift_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShift_operatorContext() *Shift_operatorContext { + var p = new(Shift_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_shift_operator + return p +} + +func InitEmptyShift_operatorContext(p *Shift_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_shift_operator +} + +func (*Shift_operatorContext) IsShift_operatorContext() {} + +func NewShift_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Shift_operatorContext { + var p = new(Shift_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_shift_operator + + return p +} + +func (s *Shift_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Shift_operatorContext) KL_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserKL_OPERATOR, 0) +} + +func (s *Shift_operatorContext) KR_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserKR_OPERATOR, 0) +} + +func (s *Shift_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Shift_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Shift_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterShift_operator(s) + } +} + +func (s *Shift_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitShift_operator(s) + } +} + +func (s *Shift_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitShift_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Shift_operator() (localctx IShift_operatorContext) { + localctx = NewShift_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 964, GoogleSQLParserRULE_shift_operator) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5977) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserKL_OPERATOR || _la == GoogleSQLParserKR_OPERATOR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdditive_operatorContext is an interface to support dynamic dispatch. +type IAdditive_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PLUS_OPERATOR() antlr.TerminalNode + MINUS_OPERATOR() antlr.TerminalNode + + // IsAdditive_operatorContext differentiates from other interfaces. + IsAdditive_operatorContext() +} + +type Additive_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdditive_operatorContext() *Additive_operatorContext { + var p = new(Additive_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_additive_operator + return p +} + +func InitEmptyAdditive_operatorContext(p *Additive_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_additive_operator +} + +func (*Additive_operatorContext) IsAdditive_operatorContext() {} + +func NewAdditive_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Additive_operatorContext { + var p = new(Additive_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_additive_operator + + return p +} + +func (s *Additive_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Additive_operatorContext) PLUS_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPLUS_OPERATOR, 0) +} + +func (s *Additive_operatorContext) MINUS_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMINUS_OPERATOR, 0) +} + +func (s *Additive_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Additive_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Additive_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterAdditive_operator(s) + } +} + +func (s *Additive_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitAdditive_operator(s) + } +} + +func (s *Additive_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitAdditive_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Additive_operator() (localctx IAdditive_operatorContext) { + localctx = NewAdditive_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 966, GoogleSQLParserRULE_additive_operator) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5979) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserPLUS_OPERATOR || _la == GoogleSQLParserMINUS_OPERATOR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMultiplicative_operatorContext is an interface to support dynamic dispatch. +type IMultiplicative_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MULTIPLY_OPERATOR() antlr.TerminalNode + DIVIDE_OPERATOR() antlr.TerminalNode + + // IsMultiplicative_operatorContext differentiates from other interfaces. + IsMultiplicative_operatorContext() +} + +type Multiplicative_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMultiplicative_operatorContext() *Multiplicative_operatorContext { + var p = new(Multiplicative_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_multiplicative_operator + return p +} + +func InitEmptyMultiplicative_operatorContext(p *Multiplicative_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_multiplicative_operator +} + +func (*Multiplicative_operatorContext) IsMultiplicative_operatorContext() {} + +func NewMultiplicative_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Multiplicative_operatorContext { + var p = new(Multiplicative_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_multiplicative_operator + + return p +} + +func (s *Multiplicative_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Multiplicative_operatorContext) MULTIPLY_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMULTIPLY_OPERATOR, 0) +} + +func (s *Multiplicative_operatorContext) DIVIDE_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDIVIDE_OPERATOR, 0) +} + +func (s *Multiplicative_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Multiplicative_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Multiplicative_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterMultiplicative_operator(s) + } +} + +func (s *Multiplicative_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitMultiplicative_operator(s) + } +} + +func (s *Multiplicative_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitMultiplicative_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Multiplicative_operator() (localctx IMultiplicative_operatorContext) { + localctx = NewMultiplicative_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 968, GoogleSQLParserRULE_multiplicative_operator) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5981) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserMULTIPLY_OPERATOR || _la == GoogleSQLParserDIVIDE_OPERATOR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIs_operatorContext is an interface to support dynamic dispatch. +type IIs_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IS_SYMBOL() antlr.TerminalNode + NOT_SYMBOL() antlr.TerminalNode + + // IsIs_operatorContext differentiates from other interfaces. + IsIs_operatorContext() +} + +type Is_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIs_operatorContext() *Is_operatorContext { + var p = new(Is_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_is_operator + return p +} + +func InitEmptyIs_operatorContext(p *Is_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_is_operator +} + +func (*Is_operatorContext) IsIs_operatorContext() {} + +func NewIs_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Is_operatorContext { + var p = new(Is_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_is_operator + + return p +} + +func (s *Is_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Is_operatorContext) IS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIS_SYMBOL, 0) +} + +func (s *Is_operatorContext) NOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNOT_SYMBOL, 0) +} + +func (s *Is_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Is_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Is_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterIs_operator(s) + } +} + +func (s *Is_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitIs_operator(s) + } +} + +func (s *Is_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitIs_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Is_operator() (localctx IIs_operatorContext) { + localctx = NewIs_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 970, GoogleSQLParserRULE_is_operator) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5983) + p.Match(GoogleSQLParserIS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5985) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserNOT_SYMBOL { + { + p.SetState(5984) + p.Match(GoogleSQLParserNOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBetween_operatorContext is an interface to support dynamic dispatch. +type IBetween_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BETWEEN_SYMBOL() antlr.TerminalNode + NOT_SYMBOL() antlr.TerminalNode + + // IsBetween_operatorContext differentiates from other interfaces. + IsBetween_operatorContext() +} + +type Between_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBetween_operatorContext() *Between_operatorContext { + var p = new(Between_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_between_operator + return p +} + +func InitEmptyBetween_operatorContext(p *Between_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_between_operator +} + +func (*Between_operatorContext) IsBetween_operatorContext() {} + +func NewBetween_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Between_operatorContext { + var p = new(Between_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_between_operator + + return p +} + +func (s *Between_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Between_operatorContext) BETWEEN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBETWEEN_SYMBOL, 0) +} + +func (s *Between_operatorContext) NOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNOT_SYMBOL, 0) +} + +func (s *Between_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Between_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Between_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterBetween_operator(s) + } +} + +func (s *Between_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitBetween_operator(s) + } +} + +func (s *Between_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitBetween_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Between_operator() (localctx IBetween_operatorContext) { + localctx = NewBetween_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 972, GoogleSQLParserRULE_between_operator) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5988) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserNOT_SYMBOL { + { + p.SetState(5987) + p.Match(GoogleSQLParserNOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5990) + p.Match(GoogleSQLParserBETWEEN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIn_operatorContext is an interface to support dynamic dispatch. +type IIn_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IN_SYMBOL() antlr.TerminalNode + NOT_SYMBOL() antlr.TerminalNode + + // IsIn_operatorContext differentiates from other interfaces. + IsIn_operatorContext() +} + +type In_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIn_operatorContext() *In_operatorContext { + var p = new(In_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_in_operator + return p +} + +func InitEmptyIn_operatorContext(p *In_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_in_operator +} + +func (*In_operatorContext) IsIn_operatorContext() {} + +func NewIn_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *In_operatorContext { + var p = new(In_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_in_operator + + return p +} + +func (s *In_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *In_operatorContext) IN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIN_SYMBOL, 0) +} + +func (s *In_operatorContext) NOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNOT_SYMBOL, 0) +} + +func (s *In_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *In_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *In_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterIn_operator(s) + } +} + +func (s *In_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitIn_operator(s) + } +} + +func (s *In_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitIn_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) In_operator() (localctx IIn_operatorContext) { + localctx = NewIn_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 974, GoogleSQLParserRULE_in_operator) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5993) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserNOT_SYMBOL { + { + p.SetState(5992) + p.Match(GoogleSQLParserNOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5995) + p.Match(GoogleSQLParserIN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDistinct_operatorContext is an interface to support dynamic dispatch. +type IDistinct_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IS_SYMBOL() antlr.TerminalNode + DISTINCT_SYMBOL() antlr.TerminalNode + FROM_SYMBOL() antlr.TerminalNode + NOT_SYMBOL() antlr.TerminalNode + + // IsDistinct_operatorContext differentiates from other interfaces. + IsDistinct_operatorContext() +} + +type Distinct_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDistinct_operatorContext() *Distinct_operatorContext { + var p = new(Distinct_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_distinct_operator + return p +} + +func InitEmptyDistinct_operatorContext(p *Distinct_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_distinct_operator +} + +func (*Distinct_operatorContext) IsDistinct_operatorContext() {} + +func NewDistinct_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Distinct_operatorContext { + var p = new(Distinct_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_distinct_operator + + return p +} + +func (s *Distinct_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Distinct_operatorContext) IS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIS_SYMBOL, 0) +} + +func (s *Distinct_operatorContext) DISTINCT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDISTINCT_SYMBOL, 0) +} + +func (s *Distinct_operatorContext) FROM_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFROM_SYMBOL, 0) +} + +func (s *Distinct_operatorContext) NOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNOT_SYMBOL, 0) +} + +func (s *Distinct_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Distinct_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Distinct_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterDistinct_operator(s) + } +} + +func (s *Distinct_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitDistinct_operator(s) + } +} + +func (s *Distinct_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitDistinct_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Distinct_operator() (localctx IDistinct_operatorContext) { + localctx = NewDistinct_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 976, GoogleSQLParserRULE_distinct_operator) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5997) + p.Match(GoogleSQLParserIS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5999) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserNOT_SYMBOL { + { + p.SetState(5998) + p.Match(GoogleSQLParserNOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6001) + p.Match(GoogleSQLParserDISTINCT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6002) + p.Match(GoogleSQLParserFROM_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParenthesized_queryContext is an interface to support dynamic dispatch. +type IParenthesized_queryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + Query() IQueryContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsParenthesized_queryContext differentiates from other interfaces. + IsParenthesized_queryContext() +} + +type Parenthesized_queryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParenthesized_queryContext() *Parenthesized_queryContext { + var p = new(Parenthesized_queryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_parenthesized_query + return p +} + +func InitEmptyParenthesized_queryContext(p *Parenthesized_queryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_parenthesized_query +} + +func (*Parenthesized_queryContext) IsParenthesized_queryContext() {} + +func NewParenthesized_queryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Parenthesized_queryContext { + var p = new(Parenthesized_queryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_parenthesized_query + + return p +} + +func (s *Parenthesized_queryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Parenthesized_queryContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Parenthesized_queryContext) Query() IQueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryContext) +} + +func (s *Parenthesized_queryContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Parenthesized_queryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Parenthesized_queryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Parenthesized_queryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterParenthesized_query(s) + } +} + +func (s *Parenthesized_queryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitParenthesized_query(s) + } +} + +func (s *Parenthesized_queryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitParenthesized_query(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Parenthesized_query() (localctx IParenthesized_queryContext) { + localctx = NewParenthesized_queryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 978, GoogleSQLParserRULE_parenthesized_query) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6004) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6005) + p.Query() + } + { + p.SetState(6006) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParenthesized_expression_not_a_queryContext is an interface to support dynamic dispatch. +type IParenthesized_expression_not_a_queryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + RR_BRACKET_SYMBOL() antlr.TerminalNode + Expression_maybe_parenthesized_not_a_query() IExpression_maybe_parenthesized_not_a_queryContext + + // IsParenthesized_expression_not_a_queryContext differentiates from other interfaces. + IsParenthesized_expression_not_a_queryContext() +} + +type Parenthesized_expression_not_a_queryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParenthesized_expression_not_a_queryContext() *Parenthesized_expression_not_a_queryContext { + var p = new(Parenthesized_expression_not_a_queryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_parenthesized_expression_not_a_query + return p +} + +func InitEmptyParenthesized_expression_not_a_queryContext(p *Parenthesized_expression_not_a_queryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_parenthesized_expression_not_a_query +} + +func (*Parenthesized_expression_not_a_queryContext) IsParenthesized_expression_not_a_queryContext() {} + +func NewParenthesized_expression_not_a_queryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Parenthesized_expression_not_a_queryContext { + var p = new(Parenthesized_expression_not_a_queryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_parenthesized_expression_not_a_query + + return p +} + +func (s *Parenthesized_expression_not_a_queryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Parenthesized_expression_not_a_queryContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Parenthesized_expression_not_a_queryContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Parenthesized_expression_not_a_queryContext) Expression_maybe_parenthesized_not_a_query() IExpression_maybe_parenthesized_not_a_queryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_maybe_parenthesized_not_a_queryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpression_maybe_parenthesized_not_a_queryContext) +} + +func (s *Parenthesized_expression_not_a_queryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Parenthesized_expression_not_a_queryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Parenthesized_expression_not_a_queryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterParenthesized_expression_not_a_query(s) + } +} + +func (s *Parenthesized_expression_not_a_queryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitParenthesized_expression_not_a_query(s) + } +} + +func (s *Parenthesized_expression_not_a_queryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitParenthesized_expression_not_a_query(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Parenthesized_expression_not_a_query() (localctx IParenthesized_expression_not_a_queryContext) { + localctx = NewParenthesized_expression_not_a_queryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 980, GoogleSQLParserRULE_parenthesized_expression_not_a_query) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6008) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(6009) + p.Expression_maybe_parenthesized_not_a_query() + } + + { + p.SetState(6010) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParenthesized_anysomeall_list_in_rhsContext is an interface to support dynamic dispatch. +type IParenthesized_anysomeall_list_in_rhsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Parenthesized_query() IParenthesized_queryContext + Parenthesized_expression_not_a_query() IParenthesized_expression_not_a_queryContext + In_list_two_or_more_prefix() IIn_list_two_or_more_prefixContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsParenthesized_anysomeall_list_in_rhsContext differentiates from other interfaces. + IsParenthesized_anysomeall_list_in_rhsContext() +} + +type Parenthesized_anysomeall_list_in_rhsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParenthesized_anysomeall_list_in_rhsContext() *Parenthesized_anysomeall_list_in_rhsContext { + var p = new(Parenthesized_anysomeall_list_in_rhsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_parenthesized_anysomeall_list_in_rhs + return p +} + +func InitEmptyParenthesized_anysomeall_list_in_rhsContext(p *Parenthesized_anysomeall_list_in_rhsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_parenthesized_anysomeall_list_in_rhs +} + +func (*Parenthesized_anysomeall_list_in_rhsContext) IsParenthesized_anysomeall_list_in_rhsContext() {} + +func NewParenthesized_anysomeall_list_in_rhsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Parenthesized_anysomeall_list_in_rhsContext { + var p = new(Parenthesized_anysomeall_list_in_rhsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_parenthesized_anysomeall_list_in_rhs + + return p +} + +func (s *Parenthesized_anysomeall_list_in_rhsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Parenthesized_anysomeall_list_in_rhsContext) Parenthesized_query() IParenthesized_queryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesized_queryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParenthesized_queryContext) +} + +func (s *Parenthesized_anysomeall_list_in_rhsContext) Parenthesized_expression_not_a_query() IParenthesized_expression_not_a_queryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesized_expression_not_a_queryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParenthesized_expression_not_a_queryContext) +} + +func (s *Parenthesized_anysomeall_list_in_rhsContext) In_list_two_or_more_prefix() IIn_list_two_or_more_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIn_list_two_or_more_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIn_list_two_or_more_prefixContext) +} + +func (s *Parenthesized_anysomeall_list_in_rhsContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Parenthesized_anysomeall_list_in_rhsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Parenthesized_anysomeall_list_in_rhsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Parenthesized_anysomeall_list_in_rhsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterParenthesized_anysomeall_list_in_rhs(s) + } +} + +func (s *Parenthesized_anysomeall_list_in_rhsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitParenthesized_anysomeall_list_in_rhs(s) + } +} + +func (s *Parenthesized_anysomeall_list_in_rhsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitParenthesized_anysomeall_list_in_rhs(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Parenthesized_anysomeall_list_in_rhs() (localctx IParenthesized_anysomeall_list_in_rhsContext) { + localctx = NewParenthesized_anysomeall_list_in_rhsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 982, GoogleSQLParserRULE_parenthesized_anysomeall_list_in_rhs) + p.SetState(6017) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 735, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6012) + p.Parenthesized_query() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6013) + p.Parenthesized_expression_not_a_query() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6014) + p.In_list_two_or_more_prefix() + } + { + p.SetState(6015) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAnd_expressionContext is an interface to support dynamic dispatch. +type IAnd_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllExpression_higher_prec_than_and() []IExpression_higher_prec_than_andContext + Expression_higher_prec_than_and(i int) IExpression_higher_prec_than_andContext + AllAND_SYMBOL() []antlr.TerminalNode + AND_SYMBOL(i int) antlr.TerminalNode + + // IsAnd_expressionContext differentiates from other interfaces. + IsAnd_expressionContext() +} + +type And_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAnd_expressionContext() *And_expressionContext { + var p = new(And_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_and_expression + return p +} + +func InitEmptyAnd_expressionContext(p *And_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_and_expression +} + +func (*And_expressionContext) IsAnd_expressionContext() {} + +func NewAnd_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *And_expressionContext { + var p = new(And_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_and_expression + + return p +} + +func (s *And_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *And_expressionContext) AllExpression_higher_prec_than_and() []IExpression_higher_prec_than_andContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpression_higher_prec_than_andContext); ok { + len++ + } + } + + tst := make([]IExpression_higher_prec_than_andContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpression_higher_prec_than_andContext); ok { + tst[i] = t.(IExpression_higher_prec_than_andContext) + i++ + } + } + + return tst +} + +func (s *And_expressionContext) Expression_higher_prec_than_and(i int) IExpression_higher_prec_than_andContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_higher_prec_than_andContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpression_higher_prec_than_andContext) +} + +func (s *And_expressionContext) AllAND_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserAND_SYMBOL) +} + +func (s *And_expressionContext) AND_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAND_SYMBOL, i) +} + +func (s *And_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *And_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *And_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterAnd_expression(s) + } +} + +func (s *And_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitAnd_expression(s) + } +} + +func (s *And_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitAnd_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) And_expression() (localctx IAnd_expressionContext) { + localctx = NewAnd_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 984, GoogleSQLParserRULE_and_expression) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6019) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(6020) + p.Match(GoogleSQLParserAND_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6021) + p.expression_higher_prec_than_and(0) + } + p.SetState(6026) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 736, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(6022) + p.Match(GoogleSQLParserAND_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6023) + p.expression_higher_prec_than_and(0) + } + + } + p.SetState(6028) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 736, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIn_list_two_or_more_prefixContext is an interface to support dynamic dispatch. +type IIn_list_two_or_more_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsIn_list_two_or_more_prefixContext differentiates from other interfaces. + IsIn_list_two_or_more_prefixContext() +} + +type In_list_two_or_more_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIn_list_two_or_more_prefixContext() *In_list_two_or_more_prefixContext { + var p = new(In_list_two_or_more_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_in_list_two_or_more_prefix + return p +} + +func InitEmptyIn_list_two_or_more_prefixContext(p *In_list_two_or_more_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_in_list_two_or_more_prefix +} + +func (*In_list_two_or_more_prefixContext) IsIn_list_two_or_more_prefixContext() {} + +func NewIn_list_two_or_more_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *In_list_two_or_more_prefixContext { + var p = new(In_list_two_or_more_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_in_list_two_or_more_prefix + + return p +} + +func (s *In_list_two_or_more_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *In_list_two_or_more_prefixContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *In_list_two_or_more_prefixContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *In_list_two_or_more_prefixContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *In_list_two_or_more_prefixContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *In_list_two_or_more_prefixContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *In_list_two_or_more_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *In_list_two_or_more_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *In_list_two_or_more_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterIn_list_two_or_more_prefix(s) + } +} + +func (s *In_list_two_or_more_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitIn_list_two_or_more_prefix(s) + } +} + +func (s *In_list_two_or_more_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitIn_list_two_or_more_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) In_list_two_or_more_prefix() (localctx IIn_list_two_or_more_prefixContext) { + localctx = NewIn_list_two_or_more_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 986, GoogleSQLParserRULE_in_list_two_or_more_prefix) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6029) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6030) + p.expression(0) + } + { + p.SetState(6031) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6032) + p.expression(0) + } + p.SetState(6037) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(6033) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6034) + p.expression(0) + } + + p.SetState(6039) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAny_some_allContext is an interface to support dynamic dispatch. +type IAny_some_allContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ANY_SYMBOL() antlr.TerminalNode + SOME_SYMBOL() antlr.TerminalNode + ALL_SYMBOL() antlr.TerminalNode + + // IsAny_some_allContext differentiates from other interfaces. + IsAny_some_allContext() +} + +type Any_some_allContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAny_some_allContext() *Any_some_allContext { + var p = new(Any_some_allContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_any_some_all + return p +} + +func InitEmptyAny_some_allContext(p *Any_some_allContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_any_some_all +} + +func (*Any_some_allContext) IsAny_some_allContext() {} + +func NewAny_some_allContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Any_some_allContext { + var p = new(Any_some_allContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_any_some_all + + return p +} + +func (s *Any_some_allContext) GetParser() antlr.Parser { return s.parser } + +func (s *Any_some_allContext) ANY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserANY_SYMBOL, 0) +} + +func (s *Any_some_allContext) SOME_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSOME_SYMBOL, 0) +} + +func (s *Any_some_allContext) ALL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserALL_SYMBOL, 0) +} + +func (s *Any_some_allContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Any_some_allContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Any_some_allContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterAny_some_all(s) + } +} + +func (s *Any_some_allContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitAny_some_all(s) + } +} + +func (s *Any_some_allContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitAny_some_all(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Any_some_all() (localctx IAny_some_allContext) { + localctx = NewAny_some_allContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 988, GoogleSQLParserRULE_any_some_all) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6040) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserALL_SYMBOL || _la == GoogleSQLParserANY_SYMBOL || _la == GoogleSQLParserSOME_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILike_operatorContext is an interface to support dynamic dispatch. +type ILike_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LIKE_SYMBOL() antlr.TerminalNode + NOT_SYMBOL() antlr.TerminalNode + + // IsLike_operatorContext differentiates from other interfaces. + IsLike_operatorContext() +} + +type Like_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLike_operatorContext() *Like_operatorContext { + var p = new(Like_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_like_operator + return p +} + +func InitEmptyLike_operatorContext(p *Like_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_like_operator +} + +func (*Like_operatorContext) IsLike_operatorContext() {} + +func NewLike_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Like_operatorContext { + var p = new(Like_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_like_operator + + return p +} + +func (s *Like_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Like_operatorContext) LIKE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLIKE_SYMBOL, 0) +} + +func (s *Like_operatorContext) NOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNOT_SYMBOL, 0) +} + +func (s *Like_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Like_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Like_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterLike_operator(s) + } +} + +func (s *Like_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitLike_operator(s) + } +} + +func (s *Like_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitLike_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Like_operator() (localctx ILike_operatorContext) { + localctx = NewLike_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 990, GoogleSQLParserRULE_like_operator) + p.SetState(6045) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserLIKE_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6042) + p.Match(GoogleSQLParserLIKE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserNOT_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6043) + p.Match(GoogleSQLParserNOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6044) + p.Match(GoogleSQLParserLIKE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpression_subquery_with_keywordContext is an interface to support dynamic dispatch. +type IExpression_subquery_with_keywordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ARRAY_SYMBOL() antlr.TerminalNode + Parenthesized_query() IParenthesized_queryContext + EXISTS_SYMBOL() antlr.TerminalNode + Hint() IHintContext + + // IsExpression_subquery_with_keywordContext differentiates from other interfaces. + IsExpression_subquery_with_keywordContext() +} + +type Expression_subquery_with_keywordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpression_subquery_with_keywordContext() *Expression_subquery_with_keywordContext { + var p = new(Expression_subquery_with_keywordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_expression_subquery_with_keyword + return p +} + +func InitEmptyExpression_subquery_with_keywordContext(p *Expression_subquery_with_keywordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_expression_subquery_with_keyword +} + +func (*Expression_subquery_with_keywordContext) IsExpression_subquery_with_keywordContext() {} + +func NewExpression_subquery_with_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expression_subquery_with_keywordContext { + var p = new(Expression_subquery_with_keywordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_expression_subquery_with_keyword + + return p +} + +func (s *Expression_subquery_with_keywordContext) GetParser() antlr.Parser { return s.parser } + +func (s *Expression_subquery_with_keywordContext) ARRAY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserARRAY_SYMBOL, 0) +} + +func (s *Expression_subquery_with_keywordContext) Parenthesized_query() IParenthesized_queryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParenthesized_queryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParenthesized_queryContext) +} + +func (s *Expression_subquery_with_keywordContext) EXISTS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXISTS_SYMBOL, 0) +} + +func (s *Expression_subquery_with_keywordContext) Hint() IHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Expression_subquery_with_keywordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Expression_subquery_with_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Expression_subquery_with_keywordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterExpression_subquery_with_keyword(s) + } +} + +func (s *Expression_subquery_with_keywordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitExpression_subquery_with_keyword(s) + } +} + +func (s *Expression_subquery_with_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitExpression_subquery_with_keyword(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Expression_subquery_with_keyword() (localctx IExpression_subquery_with_keywordContext) { + localctx = NewExpression_subquery_with_keywordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 992, GoogleSQLParserRULE_expression_subquery_with_keyword) + var _la int + + p.SetState(6054) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserARRAY_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6047) + p.Match(GoogleSQLParserARRAY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6048) + p.Parenthesized_query() + } + + case GoogleSQLParserEXISTS_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6049) + p.Match(GoogleSQLParserEXISTS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6051) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(6050) + p.Hint() + } + + } + { + p.SetState(6053) + p.Parenthesized_query() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStruct_constructorContext is an interface to support dynamic dispatch. +type IStruct_constructorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Struct_constructor_prefix_with_keyword() IStruct_constructor_prefix_with_keywordContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + Struct_constructor_prefix_with_keyword_no_arg() IStruct_constructor_prefix_with_keyword_no_argContext + Struct_constructor_prefix_without_keyword() IStruct_constructor_prefix_without_keywordContext + + // IsStruct_constructorContext differentiates from other interfaces. + IsStruct_constructorContext() +} + +type Struct_constructorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStruct_constructorContext() *Struct_constructorContext { + var p = new(Struct_constructorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_struct_constructor + return p +} + +func InitEmptyStruct_constructorContext(p *Struct_constructorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_struct_constructor +} + +func (*Struct_constructorContext) IsStruct_constructorContext() {} + +func NewStruct_constructorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Struct_constructorContext { + var p = new(Struct_constructorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_struct_constructor + + return p +} + +func (s *Struct_constructorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Struct_constructorContext) Struct_constructor_prefix_with_keyword() IStruct_constructor_prefix_with_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStruct_constructor_prefix_with_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStruct_constructor_prefix_with_keywordContext) +} + +func (s *Struct_constructorContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Struct_constructorContext) Struct_constructor_prefix_with_keyword_no_arg() IStruct_constructor_prefix_with_keyword_no_argContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStruct_constructor_prefix_with_keyword_no_argContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStruct_constructor_prefix_with_keyword_no_argContext) +} + +func (s *Struct_constructorContext) Struct_constructor_prefix_without_keyword() IStruct_constructor_prefix_without_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStruct_constructor_prefix_without_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStruct_constructor_prefix_without_keywordContext) +} + +func (s *Struct_constructorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Struct_constructorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Struct_constructorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterStruct_constructor(s) + } +} + +func (s *Struct_constructorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitStruct_constructor(s) + } +} + +func (s *Struct_constructorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitStruct_constructor(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Struct_constructor() (localctx IStruct_constructorContext) { + localctx = NewStruct_constructorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 994, GoogleSQLParserRULE_struct_constructor) + p.SetState(6065) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 741, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6056) + p.Struct_constructor_prefix_with_keyword() + } + { + p.SetState(6057) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6059) + p.Struct_constructor_prefix_with_keyword_no_arg() + } + { + p.SetState(6060) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6062) + p.Struct_constructor_prefix_without_keyword() + } + { + p.SetState(6063) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStruct_constructor_prefix_with_keywordContext is an interface to support dynamic dispatch. +type IStruct_constructor_prefix_with_keywordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Struct_constructor_prefix_with_keyword_no_arg() IStruct_constructor_prefix_with_keyword_no_argContext + AllStruct_constructor_arg() []IStruct_constructor_argContext + Struct_constructor_arg(i int) IStruct_constructor_argContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsStruct_constructor_prefix_with_keywordContext differentiates from other interfaces. + IsStruct_constructor_prefix_with_keywordContext() +} + +type Struct_constructor_prefix_with_keywordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStruct_constructor_prefix_with_keywordContext() *Struct_constructor_prefix_with_keywordContext { + var p = new(Struct_constructor_prefix_with_keywordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_struct_constructor_prefix_with_keyword + return p +} + +func InitEmptyStruct_constructor_prefix_with_keywordContext(p *Struct_constructor_prefix_with_keywordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_struct_constructor_prefix_with_keyword +} + +func (*Struct_constructor_prefix_with_keywordContext) IsStruct_constructor_prefix_with_keywordContext() { +} + +func NewStruct_constructor_prefix_with_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Struct_constructor_prefix_with_keywordContext { + var p = new(Struct_constructor_prefix_with_keywordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_struct_constructor_prefix_with_keyword + + return p +} + +func (s *Struct_constructor_prefix_with_keywordContext) GetParser() antlr.Parser { return s.parser } + +func (s *Struct_constructor_prefix_with_keywordContext) Struct_constructor_prefix_with_keyword_no_arg() IStruct_constructor_prefix_with_keyword_no_argContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStruct_constructor_prefix_with_keyword_no_argContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStruct_constructor_prefix_with_keyword_no_argContext) +} + +func (s *Struct_constructor_prefix_with_keywordContext) AllStruct_constructor_arg() []IStruct_constructor_argContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStruct_constructor_argContext); ok { + len++ + } + } + + tst := make([]IStruct_constructor_argContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStruct_constructor_argContext); ok { + tst[i] = t.(IStruct_constructor_argContext) + i++ + } + } + + return tst +} + +func (s *Struct_constructor_prefix_with_keywordContext) Struct_constructor_arg(i int) IStruct_constructor_argContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStruct_constructor_argContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStruct_constructor_argContext) +} + +func (s *Struct_constructor_prefix_with_keywordContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Struct_constructor_prefix_with_keywordContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Struct_constructor_prefix_with_keywordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Struct_constructor_prefix_with_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Struct_constructor_prefix_with_keywordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterStruct_constructor_prefix_with_keyword(s) + } +} + +func (s *Struct_constructor_prefix_with_keywordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitStruct_constructor_prefix_with_keyword(s) + } +} + +func (s *Struct_constructor_prefix_with_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitStruct_constructor_prefix_with_keyword(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Struct_constructor_prefix_with_keyword() (localctx IStruct_constructor_prefix_with_keywordContext) { + localctx = NewStruct_constructor_prefix_with_keywordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 996, GoogleSQLParserRULE_struct_constructor_prefix_with_keyword) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6067) + p.Struct_constructor_prefix_with_keyword_no_arg() + } + { + p.SetState(6068) + p.Struct_constructor_arg() + } + p.SetState(6073) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(6069) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6070) + p.Struct_constructor_arg() + } + + p.SetState(6075) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStruct_constructor_argContext is an interface to support dynamic dispatch. +type IStruct_constructor_argContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + Opt_as_alias_with_required_as() IOpt_as_alias_with_required_asContext + + // IsStruct_constructor_argContext differentiates from other interfaces. + IsStruct_constructor_argContext() +} + +type Struct_constructor_argContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStruct_constructor_argContext() *Struct_constructor_argContext { + var p = new(Struct_constructor_argContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_struct_constructor_arg + return p +} + +func InitEmptyStruct_constructor_argContext(p *Struct_constructor_argContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_struct_constructor_arg +} + +func (*Struct_constructor_argContext) IsStruct_constructor_argContext() {} + +func NewStruct_constructor_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Struct_constructor_argContext { + var p = new(Struct_constructor_argContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_struct_constructor_arg + + return p +} + +func (s *Struct_constructor_argContext) GetParser() antlr.Parser { return s.parser } + +func (s *Struct_constructor_argContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Struct_constructor_argContext) Opt_as_alias_with_required_as() IOpt_as_alias_with_required_asContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_as_alias_with_required_asContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_as_alias_with_required_asContext) +} + +func (s *Struct_constructor_argContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Struct_constructor_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Struct_constructor_argContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterStruct_constructor_arg(s) + } +} + +func (s *Struct_constructor_argContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitStruct_constructor_arg(s) + } +} + +func (s *Struct_constructor_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitStruct_constructor_arg(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Struct_constructor_arg() (localctx IStruct_constructor_argContext) { + localctx = NewStruct_constructor_argContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 998, GoogleSQLParserRULE_struct_constructor_arg) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6076) + p.expression(0) + } + p.SetState(6078) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(6077) + p.Opt_as_alias_with_required_as() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStruct_constructor_prefix_without_keywordContext is an interface to support dynamic dispatch. +type IStruct_constructor_prefix_without_keywordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsStruct_constructor_prefix_without_keywordContext differentiates from other interfaces. + IsStruct_constructor_prefix_without_keywordContext() +} + +type Struct_constructor_prefix_without_keywordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStruct_constructor_prefix_without_keywordContext() *Struct_constructor_prefix_without_keywordContext { + var p = new(Struct_constructor_prefix_without_keywordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_struct_constructor_prefix_without_keyword + return p +} + +func InitEmptyStruct_constructor_prefix_without_keywordContext(p *Struct_constructor_prefix_without_keywordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_struct_constructor_prefix_without_keyword +} + +func (*Struct_constructor_prefix_without_keywordContext) IsStruct_constructor_prefix_without_keywordContext() { +} + +func NewStruct_constructor_prefix_without_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Struct_constructor_prefix_without_keywordContext { + var p = new(Struct_constructor_prefix_without_keywordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_struct_constructor_prefix_without_keyword + + return p +} + +func (s *Struct_constructor_prefix_without_keywordContext) GetParser() antlr.Parser { return s.parser } + +func (s *Struct_constructor_prefix_without_keywordContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Struct_constructor_prefix_without_keywordContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Struct_constructor_prefix_without_keywordContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Struct_constructor_prefix_without_keywordContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Struct_constructor_prefix_without_keywordContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Struct_constructor_prefix_without_keywordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Struct_constructor_prefix_without_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Struct_constructor_prefix_without_keywordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterStruct_constructor_prefix_without_keyword(s) + } +} + +func (s *Struct_constructor_prefix_without_keywordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitStruct_constructor_prefix_without_keyword(s) + } +} + +func (s *Struct_constructor_prefix_without_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitStruct_constructor_prefix_without_keyword(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Struct_constructor_prefix_without_keyword() (localctx IStruct_constructor_prefix_without_keywordContext) { + localctx = NewStruct_constructor_prefix_without_keywordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1000, GoogleSQLParserRULE_struct_constructor_prefix_without_keyword) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6080) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6081) + p.expression(0) + } + { + p.SetState(6082) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6083) + p.expression(0) + } + p.SetState(6088) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(6084) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6085) + p.expression(0) + } + + p.SetState(6090) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStruct_constructor_prefix_with_keyword_no_argContext is an interface to support dynamic dispatch. +type IStruct_constructor_prefix_with_keyword_no_argContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Struct_type() IStruct_typeContext + LR_BRACKET_SYMBOL() antlr.TerminalNode + STRUCT_SYMBOL() antlr.TerminalNode + + // IsStruct_constructor_prefix_with_keyword_no_argContext differentiates from other interfaces. + IsStruct_constructor_prefix_with_keyword_no_argContext() +} + +type Struct_constructor_prefix_with_keyword_no_argContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStruct_constructor_prefix_with_keyword_no_argContext() *Struct_constructor_prefix_with_keyword_no_argContext { + var p = new(Struct_constructor_prefix_with_keyword_no_argContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_struct_constructor_prefix_with_keyword_no_arg + return p +} + +func InitEmptyStruct_constructor_prefix_with_keyword_no_argContext(p *Struct_constructor_prefix_with_keyword_no_argContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_struct_constructor_prefix_with_keyword_no_arg +} + +func (*Struct_constructor_prefix_with_keyword_no_argContext) IsStruct_constructor_prefix_with_keyword_no_argContext() { +} + +func NewStruct_constructor_prefix_with_keyword_no_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Struct_constructor_prefix_with_keyword_no_argContext { + var p = new(Struct_constructor_prefix_with_keyword_no_argContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_struct_constructor_prefix_with_keyword_no_arg + + return p +} + +func (s *Struct_constructor_prefix_with_keyword_no_argContext) GetParser() antlr.Parser { + return s.parser +} + +func (s *Struct_constructor_prefix_with_keyword_no_argContext) Struct_type() IStruct_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStruct_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStruct_typeContext) +} + +func (s *Struct_constructor_prefix_with_keyword_no_argContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Struct_constructor_prefix_with_keyword_no_argContext) STRUCT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTRUCT_SYMBOL, 0) +} + +func (s *Struct_constructor_prefix_with_keyword_no_argContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Struct_constructor_prefix_with_keyword_no_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Struct_constructor_prefix_with_keyword_no_argContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterStruct_constructor_prefix_with_keyword_no_arg(s) + } +} + +func (s *Struct_constructor_prefix_with_keyword_no_argContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitStruct_constructor_prefix_with_keyword_no_arg(s) + } +} + +func (s *Struct_constructor_prefix_with_keyword_no_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitStruct_constructor_prefix_with_keyword_no_arg(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Struct_constructor_prefix_with_keyword_no_arg() (localctx IStruct_constructor_prefix_with_keyword_no_argContext) { + localctx = NewStruct_constructor_prefix_with_keyword_no_argContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1002, GoogleSQLParserRULE_struct_constructor_prefix_with_keyword_no_arg) + p.SetState(6096) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 745, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6091) + p.Struct_type() + } + { + p.SetState(6092) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6094) + p.Match(GoogleSQLParserSTRUCT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6095) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInterval_expressionContext is an interface to support dynamic dispatch. +type IInterval_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INTERVAL_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + TO_SYMBOL() antlr.TerminalNode + + // IsInterval_expressionContext differentiates from other interfaces. + IsInterval_expressionContext() +} + +type Interval_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInterval_expressionContext() *Interval_expressionContext { + var p = new(Interval_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_interval_expression + return p +} + +func InitEmptyInterval_expressionContext(p *Interval_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_interval_expression +} + +func (*Interval_expressionContext) IsInterval_expressionContext() {} + +func NewInterval_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Interval_expressionContext { + var p = new(Interval_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_interval_expression + + return p +} + +func (s *Interval_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Interval_expressionContext) INTERVAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINTERVAL_SYMBOL, 0) +} + +func (s *Interval_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Interval_expressionContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Interval_expressionContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Interval_expressionContext) TO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTO_SYMBOL, 0) +} + +func (s *Interval_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Interval_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Interval_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterInterval_expression(s) + } +} + +func (s *Interval_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitInterval_expression(s) + } +} + +func (s *Interval_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitInterval_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Interval_expression() (localctx IInterval_expressionContext) { + localctx = NewInterval_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1004, GoogleSQLParserRULE_interval_expression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6098) + p.Match(GoogleSQLParserINTERVAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6099) + p.expression(0) + } + { + p.SetState(6100) + p.Identifier() + } + p.SetState(6103) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 746, p.GetParserRuleContext()) == 1 { + { + p.SetState(6101) + p.Match(GoogleSQLParserTO_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6102) + p.Identifier() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunction_call_expression_with_clausesContext is an interface to support dynamic dispatch. +type IFunction_call_expression_with_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Path_expression() IPath_expressionContext + LR_BRACKET_SYMBOL() antlr.TerminalNode + Function_call_expression_with_clauses_suffix() IFunction_call_expression_with_clauses_suffixContext + DISTINCT_SYMBOL() antlr.TerminalNode + Function_name_from_keyword() IFunction_name_from_keywordContext + + // IsFunction_call_expression_with_clausesContext differentiates from other interfaces. + IsFunction_call_expression_with_clausesContext() +} + +type Function_call_expression_with_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_call_expression_with_clausesContext() *Function_call_expression_with_clausesContext { + var p = new(Function_call_expression_with_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_function_call_expression_with_clauses + return p +} + +func InitEmptyFunction_call_expression_with_clausesContext(p *Function_call_expression_with_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_function_call_expression_with_clauses +} + +func (*Function_call_expression_with_clausesContext) IsFunction_call_expression_with_clausesContext() { +} + +func NewFunction_call_expression_with_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_call_expression_with_clausesContext { + var p = new(Function_call_expression_with_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_function_call_expression_with_clauses + + return p +} + +func (s *Function_call_expression_with_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_call_expression_with_clausesContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Function_call_expression_with_clausesContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Function_call_expression_with_clausesContext) Function_call_expression_with_clauses_suffix() IFunction_call_expression_with_clauses_suffixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_call_expression_with_clauses_suffixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_call_expression_with_clauses_suffixContext) +} + +func (s *Function_call_expression_with_clausesContext) DISTINCT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDISTINCT_SYMBOL, 0) +} + +func (s *Function_call_expression_with_clausesContext) Function_name_from_keyword() IFunction_name_from_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_name_from_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_name_from_keywordContext) +} + +func (s *Function_call_expression_with_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_call_expression_with_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_call_expression_with_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterFunction_call_expression_with_clauses(s) + } +} + +func (s *Function_call_expression_with_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitFunction_call_expression_with_clauses(s) + } +} + +func (s *Function_call_expression_with_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitFunction_call_expression_with_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Function_call_expression_with_clauses() (localctx IFunction_call_expression_with_clausesContext) { + localctx = NewFunction_call_expression_with_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1006, GoogleSQLParserRULE_function_call_expression_with_clauses) + var _la int + + p.SetState(6116) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6105) + p.Path_expression() + } + { + p.SetState(6106) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6108) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserDISTINCT_SYMBOL { + { + p.SetState(6107) + p.Match(GoogleSQLParserDISTINCT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6110) + p.Function_call_expression_with_clauses_suffix() + } + + case GoogleSQLParserLEFT_SYMBOL, GoogleSQLParserRIGHT_SYMBOL, GoogleSQLParserRANGE_SYMBOL, GoogleSQLParserCOLLATE_SYMBOL, GoogleSQLParserIF_SYMBOL, GoogleSQLParserGROUPING_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6112) + p.Function_name_from_keyword() + } + { + p.SetState(6113) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6114) + p.Function_call_expression_with_clauses_suffix() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunction_call_expression_with_clauses_suffixContext is an interface to support dynamic dispatch. +type IFunction_call_expression_with_clauses_suffixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RR_BRACKET_SYMBOL() antlr.TerminalNode + Hint() IHintContext + With_group_rows() IWith_group_rowsContext + Over_clause() IOver_clauseContext + Opt_having_or_group_by_modifier() IOpt_having_or_group_by_modifierContext + Order_by_clause() IOrder_by_clauseContext + Limit_offset_clause() ILimit_offset_clauseContext + Opt_null_handling_modifier() IOpt_null_handling_modifierContext + Clamped_between_modifier() IClamped_between_modifierContext + With_report_modifier() IWith_report_modifierContext + AllFunction_call_argument() []IFunction_call_argumentContext + Function_call_argument(i int) IFunction_call_argumentContext + MULTIPLY_OPERATOR() antlr.TerminalNode + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsFunction_call_expression_with_clauses_suffixContext differentiates from other interfaces. + IsFunction_call_expression_with_clauses_suffixContext() +} + +type Function_call_expression_with_clauses_suffixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_call_expression_with_clauses_suffixContext() *Function_call_expression_with_clauses_suffixContext { + var p = new(Function_call_expression_with_clauses_suffixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_function_call_expression_with_clauses_suffix + return p +} + +func InitEmptyFunction_call_expression_with_clauses_suffixContext(p *Function_call_expression_with_clauses_suffixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_function_call_expression_with_clauses_suffix +} + +func (*Function_call_expression_with_clauses_suffixContext) IsFunction_call_expression_with_clauses_suffixContext() { +} + +func NewFunction_call_expression_with_clauses_suffixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_call_expression_with_clauses_suffixContext { + var p = new(Function_call_expression_with_clauses_suffixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_function_call_expression_with_clauses_suffix + + return p +} + +func (s *Function_call_expression_with_clauses_suffixContext) GetParser() antlr.Parser { + return s.parser +} + +func (s *Function_call_expression_with_clauses_suffixContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Function_call_expression_with_clauses_suffixContext) Hint() IHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Function_call_expression_with_clauses_suffixContext) With_group_rows() IWith_group_rowsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_group_rowsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_group_rowsContext) +} + +func (s *Function_call_expression_with_clauses_suffixContext) Over_clause() IOver_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOver_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOver_clauseContext) +} + +func (s *Function_call_expression_with_clauses_suffixContext) Opt_having_or_group_by_modifier() IOpt_having_or_group_by_modifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_having_or_group_by_modifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_having_or_group_by_modifierContext) +} + +func (s *Function_call_expression_with_clauses_suffixContext) Order_by_clause() IOrder_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_clauseContext) +} + +func (s *Function_call_expression_with_clauses_suffixContext) Limit_offset_clause() ILimit_offset_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimit_offset_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimit_offset_clauseContext) +} + +func (s *Function_call_expression_with_clauses_suffixContext) Opt_null_handling_modifier() IOpt_null_handling_modifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_null_handling_modifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_null_handling_modifierContext) +} + +func (s *Function_call_expression_with_clauses_suffixContext) Clamped_between_modifier() IClamped_between_modifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClamped_between_modifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClamped_between_modifierContext) +} + +func (s *Function_call_expression_with_clauses_suffixContext) With_report_modifier() IWith_report_modifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_report_modifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_report_modifierContext) +} + +func (s *Function_call_expression_with_clauses_suffixContext) AllFunction_call_argument() []IFunction_call_argumentContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunction_call_argumentContext); ok { + len++ + } + } + + tst := make([]IFunction_call_argumentContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunction_call_argumentContext); ok { + tst[i] = t.(IFunction_call_argumentContext) + i++ + } + } + + return tst +} + +func (s *Function_call_expression_with_clauses_suffixContext) Function_call_argument(i int) IFunction_call_argumentContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_call_argumentContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunction_call_argumentContext) +} + +func (s *Function_call_expression_with_clauses_suffixContext) MULTIPLY_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMULTIPLY_OPERATOR, 0) +} + +func (s *Function_call_expression_with_clauses_suffixContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Function_call_expression_with_clauses_suffixContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Function_call_expression_with_clauses_suffixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_call_expression_with_clauses_suffixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_call_expression_with_clauses_suffixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterFunction_call_expression_with_clauses_suffix(s) + } +} + +func (s *Function_call_expression_with_clauses_suffixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitFunction_call_expression_with_clauses_suffix(s) + } +} + +func (s *Function_call_expression_with_clauses_suffixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitFunction_call_expression_with_clauses_suffix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Function_call_expression_with_clauses_suffix() (localctx IFunction_call_expression_with_clauses_suffixContext) { + localctx = NewFunction_call_expression_with_clauses_suffixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1008, GoogleSQLParserRULE_function_call_expression_with_clauses_suffix) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(6158) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserRR_BRACKET_SYMBOL, GoogleSQLParserLIMIT_SYMBOL, GoogleSQLParserORDER_SYMBOL, GoogleSQLParserHAVING_SYMBOL: + p.SetState(6119) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserHAVING_SYMBOL { + { + p.SetState(6118) + p.Opt_having_or_group_by_modifier() + } + + } + p.SetState(6122) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserORDER_SYMBOL { + { + p.SetState(6121) + p.Order_by_clause() + } + + } + p.SetState(6125) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLIMIT_SYMBOL { + { + p.SetState(6124) + p.Limit_offset_clause() + } + + } + { + p.SetState(6127) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserPLUS_OPERATOR, GoogleSQLParserMINUS_OPERATOR, GoogleSQLParserMULTIPLY_OPERATOR, GoogleSQLParserBITWISE_NOT_OPERATOR, GoogleSQLParserRC_BRACKET_SYMBOL, GoogleSQLParserLR_BRACKET_SYMBOL, GoogleSQLParserLS_BRACKET_SYMBOL, GoogleSQLParserQUESTION_SYMBOL, GoogleSQLParserAT_SYMBOL, GoogleSQLParserATAT_SYMBOL, GoogleSQLParserSTRING_LITERAL, GoogleSQLParserBYTES_LITERAL, GoogleSQLParserFLOATING_POINT_LITERAL, GoogleSQLParserINTEGER_LITERAL, GoogleSQLParserARRAY_SYMBOL, GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserLEFT_SYMBOL, GoogleSQLParserNULL_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserRIGHT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSELECT_SYMBOL, GoogleSQLParserSTRUCT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserWITH_SYMBOL, GoogleSQLParserTRUE_SYMBOL, GoogleSQLParserFALSE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserNOT_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserRANGE_SYMBOL, GoogleSQLParserINTERVAL_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserNEW_SYMBOL, GoogleSQLParserCASE_SYMBOL, GoogleSQLParserCAST_SYMBOL, GoogleSQLParserEXTRACT_SYMBOL, GoogleSQLParserCOLLATE_SYMBOL, GoogleSQLParserIF_SYMBOL, GoogleSQLParserGROUPING_SYMBOL, GoogleSQLParserEXISTS_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.SetState(6130) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserPLUS_OPERATOR, GoogleSQLParserMINUS_OPERATOR, GoogleSQLParserBITWISE_NOT_OPERATOR, GoogleSQLParserRC_BRACKET_SYMBOL, GoogleSQLParserLR_BRACKET_SYMBOL, GoogleSQLParserLS_BRACKET_SYMBOL, GoogleSQLParserQUESTION_SYMBOL, GoogleSQLParserAT_SYMBOL, GoogleSQLParserATAT_SYMBOL, GoogleSQLParserSTRING_LITERAL, GoogleSQLParserBYTES_LITERAL, GoogleSQLParserFLOATING_POINT_LITERAL, GoogleSQLParserINTEGER_LITERAL, GoogleSQLParserARRAY_SYMBOL, GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserLEFT_SYMBOL, GoogleSQLParserNULL_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserRIGHT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSELECT_SYMBOL, GoogleSQLParserSTRUCT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserWITH_SYMBOL, GoogleSQLParserTRUE_SYMBOL, GoogleSQLParserFALSE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserNOT_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserRANGE_SYMBOL, GoogleSQLParserINTERVAL_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserNEW_SYMBOL, GoogleSQLParserCASE_SYMBOL, GoogleSQLParserCAST_SYMBOL, GoogleSQLParserEXTRACT_SYMBOL, GoogleSQLParserCOLLATE_SYMBOL, GoogleSQLParserIF_SYMBOL, GoogleSQLParserGROUPING_SYMBOL, GoogleSQLParserEXISTS_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + { + p.SetState(6128) + p.Function_call_argument() + } + + case GoogleSQLParserMULTIPLY_OPERATOR: + { + p.SetState(6129) + p.Match(GoogleSQLParserMULTIPLY_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(6136) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(6132) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6133) + p.Function_call_argument() + } + + p.SetState(6138) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + p.SetState(6140) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserIGNORE_SYMBOL || _la == GoogleSQLParserRESPECT_SYMBOL { + { + p.SetState(6139) + p.Opt_null_handling_modifier() + } + + } + p.SetState(6143) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserHAVING_SYMBOL { + { + p.SetState(6142) + p.Opt_having_or_group_by_modifier() + } + + } + p.SetState(6146) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCLAMPED_SYMBOL { + { + p.SetState(6145) + p.Clamped_between_modifier() + } + + } + p.SetState(6149) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserWITH_SYMBOL { + { + p.SetState(6148) + p.With_report_modifier() + } + + } + p.SetState(6152) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserORDER_SYMBOL { + { + p.SetState(6151) + p.Order_by_clause() + } + + } + p.SetState(6155) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLIMIT_SYMBOL { + { + p.SetState(6154) + p.Limit_offset_clause() + } + + } + { + p.SetState(6157) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(6161) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 761, p.GetParserRuleContext()) == 1 { + { + p.SetState(6160) + p.Hint() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6164) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 762, p.GetParserRuleContext()) == 1 { + { + p.SetState(6163) + p.With_group_rows() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6167) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 763, p.GetParserRuleContext()) == 1 { + { + p.SetState(6166) + p.Over_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOver_clauseContext is an interface to support dynamic dispatch. +type IOver_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OVER_SYMBOL() antlr.TerminalNode + Window_specification() IWindow_specificationContext + + // IsOver_clauseContext differentiates from other interfaces. + IsOver_clauseContext() +} + +type Over_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOver_clauseContext() *Over_clauseContext { + var p = new(Over_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_over_clause + return p +} + +func InitEmptyOver_clauseContext(p *Over_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_over_clause +} + +func (*Over_clauseContext) IsOver_clauseContext() {} + +func NewOver_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Over_clauseContext { + var p = new(Over_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_over_clause + + return p +} + +func (s *Over_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Over_clauseContext) OVER_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOVER_SYMBOL, 0) +} + +func (s *Over_clauseContext) Window_specification() IWindow_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindow_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindow_specificationContext) +} + +func (s *Over_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Over_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Over_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOver_clause(s) + } +} + +func (s *Over_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOver_clause(s) + } +} + +func (s *Over_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOver_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Over_clause() (localctx IOver_clauseContext) { + localctx = NewOver_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1010, GoogleSQLParserRULE_over_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6169) + p.Match(GoogleSQLParserOVER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6170) + p.Window_specification() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWindow_specificationContext is an interface to support dynamic dispatch. +type IWindow_specificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + LR_BRACKET_SYMBOL() antlr.TerminalNode + RR_BRACKET_SYMBOL() antlr.TerminalNode + Partition_by_clause() IPartition_by_clauseContext + Order_by_clause() IOrder_by_clauseContext + Opt_window_frame_clause() IOpt_window_frame_clauseContext + + // IsWindow_specificationContext differentiates from other interfaces. + IsWindow_specificationContext() +} + +type Window_specificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindow_specificationContext() *Window_specificationContext { + var p = new(Window_specificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_window_specification + return p +} + +func InitEmptyWindow_specificationContext(p *Window_specificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_window_specification +} + +func (*Window_specificationContext) IsWindow_specificationContext() {} + +func NewWindow_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_specificationContext { + var p = new(Window_specificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_window_specification + + return p +} + +func (s *Window_specificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Window_specificationContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Window_specificationContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Window_specificationContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Window_specificationContext) Partition_by_clause() IPartition_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_by_clauseContext) +} + +func (s *Window_specificationContext) Order_by_clause() IOrder_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_clauseContext) +} + +func (s *Window_specificationContext) Opt_window_frame_clause() IOpt_window_frame_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_window_frame_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_window_frame_clauseContext) +} + +func (s *Window_specificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Window_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Window_specificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterWindow_specification(s) + } +} + +func (s *Window_specificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitWindow_specification(s) + } +} + +func (s *Window_specificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitWindow_specification(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Window_specification() (localctx IWindow_specificationContext) { + localctx = NewWindow_specificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1012, GoogleSQLParserRULE_window_specification) + var _la int + + p.SetState(6187) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6172) + p.Identifier() + } + + case GoogleSQLParserLR_BRACKET_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6173) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6175) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-74)) & ^0x3f) == 0 && ((int64(1)<<(_la-74))&-106523215214079) != 0) || ((int64((_la-138)) & ^0x3f) == 0 && ((int64(1)<<(_la-138))&-1) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-36028797018963969) != 0) || ((int64((_la-266)) & ^0x3f) == 0 && ((int64(1)<<(_la-266))&536870911) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&33488865) != 0) { + { + p.SetState(6174) + p.Identifier() + } + + } + p.SetState(6178) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserPARTITION_SYMBOL { + { + p.SetState(6177) + p.Partition_by_clause() + } + + } + p.SetState(6181) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserORDER_SYMBOL { + { + p.SetState(6180) + p.Order_by_clause() + } + + } + p.SetState(6184) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserRANGE_SYMBOL || _la == GoogleSQLParserROWS_SYMBOL { + { + p.SetState(6183) + p.Opt_window_frame_clause() + } + + } + { + p.SetState(6186) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_window_frame_clauseContext is an interface to support dynamic dispatch. +type IOpt_window_frame_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Frame_unit() IFrame_unitContext + BETWEEN_SYMBOL() antlr.TerminalNode + AllWindow_frame_bound() []IWindow_frame_boundContext + Window_frame_bound(i int) IWindow_frame_boundContext + AND_SYMBOL() antlr.TerminalNode + + // IsOpt_window_frame_clauseContext differentiates from other interfaces. + IsOpt_window_frame_clauseContext() +} + +type Opt_window_frame_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_window_frame_clauseContext() *Opt_window_frame_clauseContext { + var p = new(Opt_window_frame_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_window_frame_clause + return p +} + +func InitEmptyOpt_window_frame_clauseContext(p *Opt_window_frame_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_window_frame_clause +} + +func (*Opt_window_frame_clauseContext) IsOpt_window_frame_clauseContext() {} + +func NewOpt_window_frame_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_window_frame_clauseContext { + var p = new(Opt_window_frame_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_window_frame_clause + + return p +} + +func (s *Opt_window_frame_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_window_frame_clauseContext) Frame_unit() IFrame_unitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrame_unitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrame_unitContext) +} + +func (s *Opt_window_frame_clauseContext) BETWEEN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBETWEEN_SYMBOL, 0) +} + +func (s *Opt_window_frame_clauseContext) AllWindow_frame_bound() []IWindow_frame_boundContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWindow_frame_boundContext); ok { + len++ + } + } + + tst := make([]IWindow_frame_boundContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWindow_frame_boundContext); ok { + tst[i] = t.(IWindow_frame_boundContext) + i++ + } + } + + return tst +} + +func (s *Opt_window_frame_clauseContext) Window_frame_bound(i int) IWindow_frame_boundContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindow_frame_boundContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWindow_frame_boundContext) +} + +func (s *Opt_window_frame_clauseContext) AND_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAND_SYMBOL, 0) +} + +func (s *Opt_window_frame_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_window_frame_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_window_frame_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_window_frame_clause(s) + } +} + +func (s *Opt_window_frame_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_window_frame_clause(s) + } +} + +func (s *Opt_window_frame_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_window_frame_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_window_frame_clause() (localctx IOpt_window_frame_clauseContext) { + localctx = NewOpt_window_frame_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1014, GoogleSQLParserRULE_opt_window_frame_clause) + p.SetState(6198) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 769, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6189) + p.Frame_unit() + } + { + p.SetState(6190) + p.Match(GoogleSQLParserBETWEEN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6191) + p.Window_frame_bound() + } + { + p.SetState(6192) + p.Match(GoogleSQLParserAND_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6193) + p.Window_frame_bound() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6195) + p.Frame_unit() + } + { + p.SetState(6196) + p.Window_frame_bound() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWindow_frame_boundContext is an interface to support dynamic dispatch. +type IWindow_frame_boundContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNBOUNDED_SYMBOL() antlr.TerminalNode + Preceding_or_following() IPreceding_or_followingContext + CURRENT_SYMBOL() antlr.TerminalNode + ROW_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + + // IsWindow_frame_boundContext differentiates from other interfaces. + IsWindow_frame_boundContext() +} + +type Window_frame_boundContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindow_frame_boundContext() *Window_frame_boundContext { + var p = new(Window_frame_boundContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_window_frame_bound + return p +} + +func InitEmptyWindow_frame_boundContext(p *Window_frame_boundContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_window_frame_bound +} + +func (*Window_frame_boundContext) IsWindow_frame_boundContext() {} + +func NewWindow_frame_boundContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_frame_boundContext { + var p = new(Window_frame_boundContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_window_frame_bound + + return p +} + +func (s *Window_frame_boundContext) GetParser() antlr.Parser { return s.parser } + +func (s *Window_frame_boundContext) UNBOUNDED_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUNBOUNDED_SYMBOL, 0) +} + +func (s *Window_frame_boundContext) Preceding_or_following() IPreceding_or_followingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPreceding_or_followingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPreceding_or_followingContext) +} + +func (s *Window_frame_boundContext) CURRENT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCURRENT_SYMBOL, 0) +} + +func (s *Window_frame_boundContext) ROW_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserROW_SYMBOL, 0) +} + +func (s *Window_frame_boundContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Window_frame_boundContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Window_frame_boundContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Window_frame_boundContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterWindow_frame_bound(s) + } +} + +func (s *Window_frame_boundContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitWindow_frame_bound(s) + } +} + +func (s *Window_frame_boundContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitWindow_frame_bound(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Window_frame_bound() (localctx IWindow_frame_boundContext) { + localctx = NewWindow_frame_boundContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1016, GoogleSQLParserRULE_window_frame_bound) + p.SetState(6207) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserUNBOUNDED_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6200) + p.Match(GoogleSQLParserUNBOUNDED_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6201) + p.Preceding_or_following() + } + + case GoogleSQLParserCURRENT_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6202) + p.Match(GoogleSQLParserCURRENT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6203) + p.Match(GoogleSQLParserROW_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserPLUS_OPERATOR, GoogleSQLParserMINUS_OPERATOR, GoogleSQLParserBITWISE_NOT_OPERATOR, GoogleSQLParserRC_BRACKET_SYMBOL, GoogleSQLParserLR_BRACKET_SYMBOL, GoogleSQLParserLS_BRACKET_SYMBOL, GoogleSQLParserQUESTION_SYMBOL, GoogleSQLParserAT_SYMBOL, GoogleSQLParserATAT_SYMBOL, GoogleSQLParserSTRING_LITERAL, GoogleSQLParserBYTES_LITERAL, GoogleSQLParserFLOATING_POINT_LITERAL, GoogleSQLParserINTEGER_LITERAL, GoogleSQLParserARRAY_SYMBOL, GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserLEFT_SYMBOL, GoogleSQLParserNULL_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserRIGHT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSTRUCT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserWITH_SYMBOL, GoogleSQLParserTRUE_SYMBOL, GoogleSQLParserFALSE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserNOT_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserRANGE_SYMBOL, GoogleSQLParserINTERVAL_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserNEW_SYMBOL, GoogleSQLParserCASE_SYMBOL, GoogleSQLParserCAST_SYMBOL, GoogleSQLParserEXTRACT_SYMBOL, GoogleSQLParserCOLLATE_SYMBOL, GoogleSQLParserIF_SYMBOL, GoogleSQLParserGROUPING_SYMBOL, GoogleSQLParserEXISTS_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6204) + p.expression(0) + } + { + p.SetState(6205) + p.Preceding_or_following() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPreceding_or_followingContext is an interface to support dynamic dispatch. +type IPreceding_or_followingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PRECEDING_SYMBOL() antlr.TerminalNode + FOLLOWING_SYMBOL() antlr.TerminalNode + + // IsPreceding_or_followingContext differentiates from other interfaces. + IsPreceding_or_followingContext() +} + +type Preceding_or_followingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPreceding_or_followingContext() *Preceding_or_followingContext { + var p = new(Preceding_or_followingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_preceding_or_following + return p +} + +func InitEmptyPreceding_or_followingContext(p *Preceding_or_followingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_preceding_or_following +} + +func (*Preceding_or_followingContext) IsPreceding_or_followingContext() {} + +func NewPreceding_or_followingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Preceding_or_followingContext { + var p = new(Preceding_or_followingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_preceding_or_following + + return p +} + +func (s *Preceding_or_followingContext) GetParser() antlr.Parser { return s.parser } + +func (s *Preceding_or_followingContext) PRECEDING_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPRECEDING_SYMBOL, 0) +} + +func (s *Preceding_or_followingContext) FOLLOWING_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFOLLOWING_SYMBOL, 0) +} + +func (s *Preceding_or_followingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Preceding_or_followingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Preceding_or_followingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPreceding_or_following(s) + } +} + +func (s *Preceding_or_followingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPreceding_or_following(s) + } +} + +func (s *Preceding_or_followingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPreceding_or_following(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Preceding_or_following() (localctx IPreceding_or_followingContext) { + localctx = NewPreceding_or_followingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1018, GoogleSQLParserRULE_preceding_or_following) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6209) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserPRECEDING_SYMBOL || _la == GoogleSQLParserFOLLOWING_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFrame_unitContext is an interface to support dynamic dispatch. +type IFrame_unitContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROWS_SYMBOL() antlr.TerminalNode + RANGE_SYMBOL() antlr.TerminalNode + + // IsFrame_unitContext differentiates from other interfaces. + IsFrame_unitContext() +} + +type Frame_unitContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFrame_unitContext() *Frame_unitContext { + var p = new(Frame_unitContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_frame_unit + return p +} + +func InitEmptyFrame_unitContext(p *Frame_unitContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_frame_unit +} + +func (*Frame_unitContext) IsFrame_unitContext() {} + +func NewFrame_unitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Frame_unitContext { + var p = new(Frame_unitContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_frame_unit + + return p +} + +func (s *Frame_unitContext) GetParser() antlr.Parser { return s.parser } + +func (s *Frame_unitContext) ROWS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserROWS_SYMBOL, 0) +} + +func (s *Frame_unitContext) RANGE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRANGE_SYMBOL, 0) +} + +func (s *Frame_unitContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Frame_unitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Frame_unitContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterFrame_unit(s) + } +} + +func (s *Frame_unitContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitFrame_unit(s) + } +} + +func (s *Frame_unitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitFrame_unit(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Frame_unit() (localctx IFrame_unitContext) { + localctx = NewFrame_unitContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1020, GoogleSQLParserRULE_frame_unit) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6211) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserRANGE_SYMBOL || _la == GoogleSQLParserROWS_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartition_by_clauseContext is an interface to support dynamic dispatch. +type IPartition_by_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Partition_by_clause_prefix() IPartition_by_clause_prefixContext + + // IsPartition_by_clauseContext differentiates from other interfaces. + IsPartition_by_clauseContext() +} + +type Partition_by_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartition_by_clauseContext() *Partition_by_clauseContext { + var p = new(Partition_by_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_partition_by_clause + return p +} + +func InitEmptyPartition_by_clauseContext(p *Partition_by_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_partition_by_clause +} + +func (*Partition_by_clauseContext) IsPartition_by_clauseContext() {} + +func NewPartition_by_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_by_clauseContext { + var p = new(Partition_by_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_partition_by_clause + + return p +} + +func (s *Partition_by_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partition_by_clauseContext) Partition_by_clause_prefix() IPartition_by_clause_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_by_clause_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_by_clause_prefixContext) +} + +func (s *Partition_by_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partition_by_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partition_by_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPartition_by_clause(s) + } +} + +func (s *Partition_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPartition_by_clause(s) + } +} + +func (s *Partition_by_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPartition_by_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Partition_by_clause() (localctx IPartition_by_clauseContext) { + localctx = NewPartition_by_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1022, GoogleSQLParserRULE_partition_by_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6213) + p.Partition_by_clause_prefix() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartition_by_clause_prefixContext is an interface to support dynamic dispatch. +type IPartition_by_clause_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION_SYMBOL() antlr.TerminalNode + BY_SYMBOL() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + Hint() IHintContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsPartition_by_clause_prefixContext differentiates from other interfaces. + IsPartition_by_clause_prefixContext() +} + +type Partition_by_clause_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartition_by_clause_prefixContext() *Partition_by_clause_prefixContext { + var p = new(Partition_by_clause_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_partition_by_clause_prefix + return p +} + +func InitEmptyPartition_by_clause_prefixContext(p *Partition_by_clause_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_partition_by_clause_prefix +} + +func (*Partition_by_clause_prefixContext) IsPartition_by_clause_prefixContext() {} + +func NewPartition_by_clause_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_by_clause_prefixContext { + var p = new(Partition_by_clause_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_partition_by_clause_prefix + + return p +} + +func (s *Partition_by_clause_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partition_by_clause_prefixContext) PARTITION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPARTITION_SYMBOL, 0) +} + +func (s *Partition_by_clause_prefixContext) BY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBY_SYMBOL, 0) +} + +func (s *Partition_by_clause_prefixContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Partition_by_clause_prefixContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Partition_by_clause_prefixContext) Hint() IHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Partition_by_clause_prefixContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Partition_by_clause_prefixContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Partition_by_clause_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partition_by_clause_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partition_by_clause_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPartition_by_clause_prefix(s) + } +} + +func (s *Partition_by_clause_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPartition_by_clause_prefix(s) + } +} + +func (s *Partition_by_clause_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPartition_by_clause_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Partition_by_clause_prefix() (localctx IPartition_by_clause_prefixContext) { + localctx = NewPartition_by_clause_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1024, GoogleSQLParserRULE_partition_by_clause_prefix) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6215) + p.Match(GoogleSQLParserPARTITION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6217) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(6216) + p.Hint() + } + + } + { + p.SetState(6219) + p.Match(GoogleSQLParserBY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6220) + p.expression(0) + } + p.SetState(6225) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(6221) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6222) + p.expression(0) + } + + p.SetState(6227) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWith_group_rowsContext is an interface to support dynamic dispatch. +type IWith_group_rowsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH_SYMBOL() antlr.TerminalNode + GROUP_SYMBOL() antlr.TerminalNode + ROWS_SYMBOL() antlr.TerminalNode + + // IsWith_group_rowsContext differentiates from other interfaces. + IsWith_group_rowsContext() +} + +type With_group_rowsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWith_group_rowsContext() *With_group_rowsContext { + var p = new(With_group_rowsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_with_group_rows + return p +} + +func InitEmptyWith_group_rowsContext(p *With_group_rowsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_with_group_rows +} + +func (*With_group_rowsContext) IsWith_group_rowsContext() {} + +func NewWith_group_rowsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_group_rowsContext { + var p = new(With_group_rowsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_with_group_rows + + return p +} + +func (s *With_group_rowsContext) GetParser() antlr.Parser { return s.parser } + +func (s *With_group_rowsContext) WITH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWITH_SYMBOL, 0) +} + +func (s *With_group_rowsContext) GROUP_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserGROUP_SYMBOL, 0) +} + +func (s *With_group_rowsContext) ROWS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserROWS_SYMBOL, 0) +} + +func (s *With_group_rowsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *With_group_rowsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *With_group_rowsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterWith_group_rows(s) + } +} + +func (s *With_group_rowsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitWith_group_rows(s) + } +} + +func (s *With_group_rowsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitWith_group_rows(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) With_group_rows() (localctx IWith_group_rowsContext) { + localctx = NewWith_group_rowsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1026, GoogleSQLParserRULE_with_group_rows) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6228) + p.Match(GoogleSQLParserWITH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6229) + p.Match(GoogleSQLParserGROUP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6230) + p.Match(GoogleSQLParserROWS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWith_report_modifierContext is an interface to support dynamic dispatch. +type IWith_report_modifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH_SYMBOL() antlr.TerminalNode + REPORT_SYMBOL() antlr.TerminalNode + With_report_format() IWith_report_formatContext + + // IsWith_report_modifierContext differentiates from other interfaces. + IsWith_report_modifierContext() +} + +type With_report_modifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWith_report_modifierContext() *With_report_modifierContext { + var p = new(With_report_modifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_with_report_modifier + return p +} + +func InitEmptyWith_report_modifierContext(p *With_report_modifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_with_report_modifier +} + +func (*With_report_modifierContext) IsWith_report_modifierContext() {} + +func NewWith_report_modifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_report_modifierContext { + var p = new(With_report_modifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_with_report_modifier + + return p +} + +func (s *With_report_modifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *With_report_modifierContext) WITH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWITH_SYMBOL, 0) +} + +func (s *With_report_modifierContext) REPORT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREPORT_SYMBOL, 0) +} + +func (s *With_report_modifierContext) With_report_format() IWith_report_formatContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_report_formatContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_report_formatContext) +} + +func (s *With_report_modifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *With_report_modifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *With_report_modifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterWith_report_modifier(s) + } +} + +func (s *With_report_modifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitWith_report_modifier(s) + } +} + +func (s *With_report_modifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitWith_report_modifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) With_report_modifier() (localctx IWith_report_modifierContext) { + localctx = NewWith_report_modifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1028, GoogleSQLParserRULE_with_report_modifier) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6232) + p.Match(GoogleSQLParserWITH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6233) + p.Match(GoogleSQLParserREPORT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6234) + p.With_report_format() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClamped_between_modifierContext is an interface to support dynamic dispatch. +type IClamped_between_modifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CLAMPED_SYMBOL() antlr.TerminalNode + Expression_higher_prec_than_and() IExpression_higher_prec_than_andContext + AND_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + + // IsClamped_between_modifierContext differentiates from other interfaces. + IsClamped_between_modifierContext() +} + +type Clamped_between_modifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClamped_between_modifierContext() *Clamped_between_modifierContext { + var p = new(Clamped_between_modifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_clamped_between_modifier + return p +} + +func InitEmptyClamped_between_modifierContext(p *Clamped_between_modifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_clamped_between_modifier +} + +func (*Clamped_between_modifierContext) IsClamped_between_modifierContext() {} + +func NewClamped_between_modifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Clamped_between_modifierContext { + var p = new(Clamped_between_modifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_clamped_between_modifier + + return p +} + +func (s *Clamped_between_modifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *Clamped_between_modifierContext) CLAMPED_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCLAMPED_SYMBOL, 0) +} + +func (s *Clamped_between_modifierContext) Expression_higher_prec_than_and() IExpression_higher_prec_than_andContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_higher_prec_than_andContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpression_higher_prec_than_andContext) +} + +func (s *Clamped_between_modifierContext) AND_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAND_SYMBOL, 0) +} + +func (s *Clamped_between_modifierContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Clamped_between_modifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Clamped_between_modifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Clamped_between_modifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterClamped_between_modifier(s) + } +} + +func (s *Clamped_between_modifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitClamped_between_modifier(s) + } +} + +func (s *Clamped_between_modifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitClamped_between_modifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Clamped_between_modifier() (localctx IClamped_between_modifierContext) { + localctx = NewClamped_between_modifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1030, GoogleSQLParserRULE_clamped_between_modifier) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6236) + p.Match(GoogleSQLParserCLAMPED_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6237) + p.expression_higher_prec_than_and(0) + } + { + p.SetState(6238) + p.Match(GoogleSQLParserAND_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6239) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWith_report_formatContext is an interface to support dynamic dispatch. +type IWith_report_formatContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Options_list() IOptions_listContext + + // IsWith_report_formatContext differentiates from other interfaces. + IsWith_report_formatContext() +} + +type With_report_formatContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWith_report_formatContext() *With_report_formatContext { + var p = new(With_report_formatContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_with_report_format + return p +} + +func InitEmptyWith_report_formatContext(p *With_report_formatContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_with_report_format +} + +func (*With_report_formatContext) IsWith_report_formatContext() {} + +func NewWith_report_formatContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_report_formatContext { + var p = new(With_report_formatContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_with_report_format + + return p +} + +func (s *With_report_formatContext) GetParser() antlr.Parser { return s.parser } + +func (s *With_report_formatContext) Options_list() IOptions_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptions_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptions_listContext) +} + +func (s *With_report_formatContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *With_report_formatContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *With_report_formatContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterWith_report_format(s) + } +} + +func (s *With_report_formatContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitWith_report_format(s) + } +} + +func (s *With_report_formatContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitWith_report_format(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) With_report_format() (localctx IWith_report_formatContext) { + localctx = NewWith_report_formatContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1032, GoogleSQLParserRULE_with_report_format) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6241) + p.Options_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOptions_listContext is an interface to support dynamic dispatch. +type IOptions_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Options_list_prefix() IOptions_list_prefixContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsOptions_listContext differentiates from other interfaces. + IsOptions_listContext() +} + +type Options_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOptions_listContext() *Options_listContext { + var p = new(Options_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_options_list + return p +} + +func InitEmptyOptions_listContext(p *Options_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_options_list +} + +func (*Options_listContext) IsOptions_listContext() {} + +func NewOptions_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Options_listContext { + var p = new(Options_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_options_list + + return p +} + +func (s *Options_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Options_listContext) Options_list_prefix() IOptions_list_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptions_list_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptions_list_prefixContext) +} + +func (s *Options_listContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Options_listContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Options_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Options_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Options_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOptions_list(s) + } +} + +func (s *Options_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOptions_list(s) + } +} + +func (s *Options_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOptions_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Options_list() (localctx IOptions_listContext) { + localctx = NewOptions_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1034, GoogleSQLParserRULE_options_list) + p.SetState(6248) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 773, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6243) + p.Options_list_prefix() + } + { + p.SetState(6244) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6246) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6247) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOptions_list_prefixContext is an interface to support dynamic dispatch. +type IOptions_list_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + AllOptions_entry() []IOptions_entryContext + Options_entry(i int) IOptions_entryContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsOptions_list_prefixContext differentiates from other interfaces. + IsOptions_list_prefixContext() +} + +type Options_list_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOptions_list_prefixContext() *Options_list_prefixContext { + var p = new(Options_list_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_options_list_prefix + return p +} + +func InitEmptyOptions_list_prefixContext(p *Options_list_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_options_list_prefix +} + +func (*Options_list_prefixContext) IsOptions_list_prefixContext() {} + +func NewOptions_list_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Options_list_prefixContext { + var p = new(Options_list_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_options_list_prefix + + return p +} + +func (s *Options_list_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Options_list_prefixContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Options_list_prefixContext) AllOptions_entry() []IOptions_entryContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOptions_entryContext); ok { + len++ + } + } + + tst := make([]IOptions_entryContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOptions_entryContext); ok { + tst[i] = t.(IOptions_entryContext) + i++ + } + } + + return tst +} + +func (s *Options_list_prefixContext) Options_entry(i int) IOptions_entryContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptions_entryContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOptions_entryContext) +} + +func (s *Options_list_prefixContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Options_list_prefixContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Options_list_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Options_list_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Options_list_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOptions_list_prefix(s) + } +} + +func (s *Options_list_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOptions_list_prefix(s) + } +} + +func (s *Options_list_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOptions_list_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Options_list_prefix() (localctx IOptions_list_prefixContext) { + localctx = NewOptions_list_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1036, GoogleSQLParserRULE_options_list_prefix) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6250) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6251) + p.Options_entry() + } + p.SetState(6256) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(6252) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6253) + p.Options_entry() + } + + p.SetState(6258) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOptions_entryContext is an interface to support dynamic dispatch. +type IOptions_entryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier_in_hints() IIdentifier_in_hintsContext + Options_assignment_operator() IOptions_assignment_operatorContext + Expression_or_proto() IExpression_or_protoContext + + // IsOptions_entryContext differentiates from other interfaces. + IsOptions_entryContext() +} + +type Options_entryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOptions_entryContext() *Options_entryContext { + var p = new(Options_entryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_options_entry + return p +} + +func InitEmptyOptions_entryContext(p *Options_entryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_options_entry +} + +func (*Options_entryContext) IsOptions_entryContext() {} + +func NewOptions_entryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Options_entryContext { + var p = new(Options_entryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_options_entry + + return p +} + +func (s *Options_entryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Options_entryContext) Identifier_in_hints() IIdentifier_in_hintsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifier_in_hintsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifier_in_hintsContext) +} + +func (s *Options_entryContext) Options_assignment_operator() IOptions_assignment_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptions_assignment_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptions_assignment_operatorContext) +} + +func (s *Options_entryContext) Expression_or_proto() IExpression_or_protoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_or_protoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpression_or_protoContext) +} + +func (s *Options_entryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Options_entryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Options_entryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOptions_entry(s) + } +} + +func (s *Options_entryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOptions_entry(s) + } +} + +func (s *Options_entryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOptions_entry(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Options_entry() (localctx IOptions_entryContext) { + localctx = NewOptions_entryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1038, GoogleSQLParserRULE_options_entry) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6259) + p.Identifier_in_hints() + } + { + p.SetState(6260) + p.Options_assignment_operator() + } + { + p.SetState(6261) + p.Expression_or_proto() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpression_or_protoContext is an interface to support dynamic dispatch. +type IExpression_or_protoContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PROTO_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + + // IsExpression_or_protoContext differentiates from other interfaces. + IsExpression_or_protoContext() +} + +type Expression_or_protoContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpression_or_protoContext() *Expression_or_protoContext { + var p = new(Expression_or_protoContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_expression_or_proto + return p +} + +func InitEmptyExpression_or_protoContext(p *Expression_or_protoContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_expression_or_proto +} + +func (*Expression_or_protoContext) IsExpression_or_protoContext() {} + +func NewExpression_or_protoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expression_or_protoContext { + var p = new(Expression_or_protoContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_expression_or_proto + + return p +} + +func (s *Expression_or_protoContext) GetParser() antlr.Parser { return s.parser } + +func (s *Expression_or_protoContext) PROTO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPROTO_SYMBOL, 0) +} + +func (s *Expression_or_protoContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Expression_or_protoContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Expression_or_protoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Expression_or_protoContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterExpression_or_proto(s) + } +} + +func (s *Expression_or_protoContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitExpression_or_proto(s) + } +} + +func (s *Expression_or_protoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitExpression_or_proto(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Expression_or_proto() (localctx IExpression_or_protoContext) { + localctx = NewExpression_or_protoContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1040, GoogleSQLParserRULE_expression_or_proto) + p.SetState(6265) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserPROTO_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6263) + p.Match(GoogleSQLParserPROTO_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserPLUS_OPERATOR, GoogleSQLParserMINUS_OPERATOR, GoogleSQLParserBITWISE_NOT_OPERATOR, GoogleSQLParserRC_BRACKET_SYMBOL, GoogleSQLParserLR_BRACKET_SYMBOL, GoogleSQLParserLS_BRACKET_SYMBOL, GoogleSQLParserQUESTION_SYMBOL, GoogleSQLParserAT_SYMBOL, GoogleSQLParserATAT_SYMBOL, GoogleSQLParserSTRING_LITERAL, GoogleSQLParserBYTES_LITERAL, GoogleSQLParserFLOATING_POINT_LITERAL, GoogleSQLParserINTEGER_LITERAL, GoogleSQLParserARRAY_SYMBOL, GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserLEFT_SYMBOL, GoogleSQLParserNULL_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserRIGHT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSTRUCT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserWITH_SYMBOL, GoogleSQLParserTRUE_SYMBOL, GoogleSQLParserFALSE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserNOT_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserRANGE_SYMBOL, GoogleSQLParserINTERVAL_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserNEW_SYMBOL, GoogleSQLParserCASE_SYMBOL, GoogleSQLParserCAST_SYMBOL, GoogleSQLParserEXTRACT_SYMBOL, GoogleSQLParserCOLLATE_SYMBOL, GoogleSQLParserIF_SYMBOL, GoogleSQLParserGROUPING_SYMBOL, GoogleSQLParserEXISTS_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6264) + p.expression(0) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOptions_assignment_operatorContext is an interface to support dynamic dispatch. +type IOptions_assignment_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EQUAL_OPERATOR() antlr.TerminalNode + PLUS_EQUAL_SYMBOL() antlr.TerminalNode + SUB_EQUAL_SYMBOL() antlr.TerminalNode + + // IsOptions_assignment_operatorContext differentiates from other interfaces. + IsOptions_assignment_operatorContext() +} + +type Options_assignment_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOptions_assignment_operatorContext() *Options_assignment_operatorContext { + var p = new(Options_assignment_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_options_assignment_operator + return p +} + +func InitEmptyOptions_assignment_operatorContext(p *Options_assignment_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_options_assignment_operator +} + +func (*Options_assignment_operatorContext) IsOptions_assignment_operatorContext() {} + +func NewOptions_assignment_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Options_assignment_operatorContext { + var p = new(Options_assignment_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_options_assignment_operator + + return p +} + +func (s *Options_assignment_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Options_assignment_operatorContext) EQUAL_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEQUAL_OPERATOR, 0) +} + +func (s *Options_assignment_operatorContext) PLUS_EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPLUS_EQUAL_SYMBOL, 0) +} + +func (s *Options_assignment_operatorContext) SUB_EQUAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSUB_EQUAL_SYMBOL, 0) +} + +func (s *Options_assignment_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Options_assignment_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Options_assignment_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOptions_assignment_operator(s) + } +} + +func (s *Options_assignment_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOptions_assignment_operator(s) + } +} + +func (s *Options_assignment_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOptions_assignment_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Options_assignment_operator() (localctx IOptions_assignment_operatorContext) { + localctx = NewOptions_assignment_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1042, GoogleSQLParserRULE_options_assignment_operator) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6267) + _la = p.GetTokenStream().LA(1) + + if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&824633720834) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_null_handling_modifierContext is an interface to support dynamic dispatch. +type IOpt_null_handling_modifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IGNORE_SYMBOL() antlr.TerminalNode + NULLS_SYMBOL() antlr.TerminalNode + RESPECT_SYMBOL() antlr.TerminalNode + + // IsOpt_null_handling_modifierContext differentiates from other interfaces. + IsOpt_null_handling_modifierContext() +} + +type Opt_null_handling_modifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_null_handling_modifierContext() *Opt_null_handling_modifierContext { + var p = new(Opt_null_handling_modifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_null_handling_modifier + return p +} + +func InitEmptyOpt_null_handling_modifierContext(p *Opt_null_handling_modifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_null_handling_modifier +} + +func (*Opt_null_handling_modifierContext) IsOpt_null_handling_modifierContext() {} + +func NewOpt_null_handling_modifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_null_handling_modifierContext { + var p = new(Opt_null_handling_modifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_null_handling_modifier + + return p +} + +func (s *Opt_null_handling_modifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_null_handling_modifierContext) IGNORE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIGNORE_SYMBOL, 0) +} + +func (s *Opt_null_handling_modifierContext) NULLS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNULLS_SYMBOL, 0) +} + +func (s *Opt_null_handling_modifierContext) RESPECT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRESPECT_SYMBOL, 0) +} + +func (s *Opt_null_handling_modifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_null_handling_modifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_null_handling_modifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_null_handling_modifier(s) + } +} + +func (s *Opt_null_handling_modifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_null_handling_modifier(s) + } +} + +func (s *Opt_null_handling_modifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_null_handling_modifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_null_handling_modifier() (localctx IOpt_null_handling_modifierContext) { + localctx = NewOpt_null_handling_modifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1044, GoogleSQLParserRULE_opt_null_handling_modifier) + p.SetState(6273) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserIGNORE_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6269) + p.Match(GoogleSQLParserIGNORE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6270) + p.Match(GoogleSQLParserNULLS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case GoogleSQLParserRESPECT_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6271) + p.Match(GoogleSQLParserRESPECT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6272) + p.Match(GoogleSQLParserNULLS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunction_call_argumentContext is an interface to support dynamic dispatch. +type IFunction_call_argumentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + Opt_as_alias_with_required_as() IOpt_as_alias_with_required_asContext + Named_argument() INamed_argumentContext + Lambda_argument() ILambda_argumentContext + Sequence_arg() ISequence_argContext + SELECT_SYMBOL() antlr.TerminalNode + + // IsFunction_call_argumentContext differentiates from other interfaces. + IsFunction_call_argumentContext() +} + +type Function_call_argumentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_call_argumentContext() *Function_call_argumentContext { + var p = new(Function_call_argumentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_function_call_argument + return p +} + +func InitEmptyFunction_call_argumentContext(p *Function_call_argumentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_function_call_argument +} + +func (*Function_call_argumentContext) IsFunction_call_argumentContext() {} + +func NewFunction_call_argumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_call_argumentContext { + var p = new(Function_call_argumentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_function_call_argument + + return p +} + +func (s *Function_call_argumentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_call_argumentContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Function_call_argumentContext) Opt_as_alias_with_required_as() IOpt_as_alias_with_required_asContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_as_alias_with_required_asContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_as_alias_with_required_asContext) +} + +func (s *Function_call_argumentContext) Named_argument() INamed_argumentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INamed_argumentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INamed_argumentContext) +} + +func (s *Function_call_argumentContext) Lambda_argument() ILambda_argumentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILambda_argumentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILambda_argumentContext) +} + +func (s *Function_call_argumentContext) Sequence_arg() ISequence_argContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISequence_argContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISequence_argContext) +} + +func (s *Function_call_argumentContext) SELECT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSELECT_SYMBOL, 0) +} + +func (s *Function_call_argumentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_call_argumentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_call_argumentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterFunction_call_argument(s) + } +} + +func (s *Function_call_argumentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitFunction_call_argument(s) + } +} + +func (s *Function_call_argumentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitFunction_call_argument(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Function_call_argument() (localctx IFunction_call_argumentContext) { + localctx = NewFunction_call_argumentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1046, GoogleSQLParserRULE_function_call_argument) + var _la int + + p.SetState(6284) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 778, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6275) + p.expression(0) + } + p.SetState(6277) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAS_SYMBOL { + { + p.SetState(6276) + p.Opt_as_alias_with_required_as() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6279) + p.Named_argument() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6280) + p.Lambda_argument() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6281) + p.Sequence_arg() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6282) + p.Match(GoogleSQLParserSELECT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.NotifyErrorListeners("Each function argument is an expression, not a query; to use a query as an expression, the query must be wrapped with additional parentheses to make it a scalar subquery expression", nil, nil) + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISequence_argContext is an interface to support dynamic dispatch. +type ISequence_argContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SEQUENCE_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + + // IsSequence_argContext differentiates from other interfaces. + IsSequence_argContext() +} + +type Sequence_argContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySequence_argContext() *Sequence_argContext { + var p = new(Sequence_argContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_sequence_arg + return p +} + +func InitEmptySequence_argContext(p *Sequence_argContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_sequence_arg +} + +func (*Sequence_argContext) IsSequence_argContext() {} + +func NewSequence_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sequence_argContext { + var p = new(Sequence_argContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_sequence_arg + + return p +} + +func (s *Sequence_argContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sequence_argContext) SEQUENCE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSEQUENCE_SYMBOL, 0) +} + +func (s *Sequence_argContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Sequence_argContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sequence_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sequence_argContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSequence_arg(s) + } +} + +func (s *Sequence_argContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSequence_arg(s) + } +} + +func (s *Sequence_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSequence_arg(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Sequence_arg() (localctx ISequence_argContext) { + localctx = NewSequence_argContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1048, GoogleSQLParserRULE_sequence_arg) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6286) + p.Match(GoogleSQLParserSEQUENCE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6287) + p.Path_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INamed_argumentContext is an interface to support dynamic dispatch. +type INamed_argumentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + EQUAL_GT_BRACKET_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + Lambda_argument() ILambda_argumentContext + + // IsNamed_argumentContext differentiates from other interfaces. + IsNamed_argumentContext() +} + +type Named_argumentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNamed_argumentContext() *Named_argumentContext { + var p = new(Named_argumentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_named_argument + return p +} + +func InitEmptyNamed_argumentContext(p *Named_argumentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_named_argument +} + +func (*Named_argumentContext) IsNamed_argumentContext() {} + +func NewNamed_argumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Named_argumentContext { + var p = new(Named_argumentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_named_argument + + return p +} + +func (s *Named_argumentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Named_argumentContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Named_argumentContext) EQUAL_GT_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEQUAL_GT_BRACKET_SYMBOL, 0) +} + +func (s *Named_argumentContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Named_argumentContext) Lambda_argument() ILambda_argumentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILambda_argumentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILambda_argumentContext) +} + +func (s *Named_argumentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Named_argumentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Named_argumentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterNamed_argument(s) + } +} + +func (s *Named_argumentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitNamed_argument(s) + } +} + +func (s *Named_argumentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitNamed_argument(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Named_argument() (localctx INamed_argumentContext) { + localctx = NewNamed_argumentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1050, GoogleSQLParserRULE_named_argument) + p.SetState(6297) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 779, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6289) + p.Identifier() + } + { + p.SetState(6290) + p.Match(GoogleSQLParserEQUAL_GT_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6291) + p.expression(0) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6293) + p.Identifier() + } + { + p.SetState(6294) + p.Match(GoogleSQLParserEQUAL_GT_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6295) + p.Lambda_argument() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILambda_argumentContext is an interface to support dynamic dispatch. +type ILambda_argumentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Lambda_argument_list() ILambda_argument_listContext + SUB_GT_BRACKET_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + + // IsLambda_argumentContext differentiates from other interfaces. + IsLambda_argumentContext() +} + +type Lambda_argumentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLambda_argumentContext() *Lambda_argumentContext { + var p = new(Lambda_argumentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_lambda_argument + return p +} + +func InitEmptyLambda_argumentContext(p *Lambda_argumentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_lambda_argument +} + +func (*Lambda_argumentContext) IsLambda_argumentContext() {} + +func NewLambda_argumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lambda_argumentContext { + var p = new(Lambda_argumentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_lambda_argument + + return p +} + +func (s *Lambda_argumentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lambda_argumentContext) Lambda_argument_list() ILambda_argument_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILambda_argument_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILambda_argument_listContext) +} + +func (s *Lambda_argumentContext) SUB_GT_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSUB_GT_BRACKET_SYMBOL, 0) +} + +func (s *Lambda_argumentContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Lambda_argumentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lambda_argumentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lambda_argumentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterLambda_argument(s) + } +} + +func (s *Lambda_argumentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitLambda_argument(s) + } +} + +func (s *Lambda_argumentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitLambda_argument(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Lambda_argument() (localctx ILambda_argumentContext) { + localctx = NewLambda_argumentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1052, GoogleSQLParserRULE_lambda_argument) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6299) + p.Lambda_argument_list() + } + { + p.SetState(6300) + p.Match(GoogleSQLParserSUB_GT_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6301) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILambda_argument_listContext is an interface to support dynamic dispatch. +type ILambda_argument_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + LR_BRACKET_SYMBOL() antlr.TerminalNode + RR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsLambda_argument_listContext differentiates from other interfaces. + IsLambda_argument_listContext() +} + +type Lambda_argument_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLambda_argument_listContext() *Lambda_argument_listContext { + var p = new(Lambda_argument_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_lambda_argument_list + return p +} + +func InitEmptyLambda_argument_listContext(p *Lambda_argument_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_lambda_argument_list +} + +func (*Lambda_argument_listContext) IsLambda_argument_listContext() {} + +func NewLambda_argument_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lambda_argument_listContext { + var p = new(Lambda_argument_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_lambda_argument_list + + return p +} + +func (s *Lambda_argument_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lambda_argument_listContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Lambda_argument_listContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Lambda_argument_listContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Lambda_argument_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lambda_argument_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lambda_argument_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterLambda_argument_list(s) + } +} + +func (s *Lambda_argument_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitLambda_argument_list(s) + } +} + +func (s *Lambda_argument_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitLambda_argument_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Lambda_argument_list() (localctx ILambda_argument_listContext) { + localctx = NewLambda_argument_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1054, GoogleSQLParserRULE_lambda_argument_list) + p.SetState(6306) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 780, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6303) + p.expression(0) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6304) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6305) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILimit_offset_clauseContext is an interface to support dynamic dispatch. +type ILimit_offset_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LIMIT_SYMBOL() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + OFFSET_SYMBOL() antlr.TerminalNode + + // IsLimit_offset_clauseContext differentiates from other interfaces. + IsLimit_offset_clauseContext() +} + +type Limit_offset_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLimit_offset_clauseContext() *Limit_offset_clauseContext { + var p = new(Limit_offset_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_limit_offset_clause + return p +} + +func InitEmptyLimit_offset_clauseContext(p *Limit_offset_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_limit_offset_clause +} + +func (*Limit_offset_clauseContext) IsLimit_offset_clauseContext() {} + +func NewLimit_offset_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Limit_offset_clauseContext { + var p = new(Limit_offset_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_limit_offset_clause + + return p +} + +func (s *Limit_offset_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Limit_offset_clauseContext) LIMIT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLIMIT_SYMBOL, 0) +} + +func (s *Limit_offset_clauseContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Limit_offset_clauseContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Limit_offset_clauseContext) OFFSET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOFFSET_SYMBOL, 0) +} + +func (s *Limit_offset_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Limit_offset_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Limit_offset_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterLimit_offset_clause(s) + } +} + +func (s *Limit_offset_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitLimit_offset_clause(s) + } +} + +func (s *Limit_offset_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitLimit_offset_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Limit_offset_clause() (localctx ILimit_offset_clauseContext) { + localctx = NewLimit_offset_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1056, GoogleSQLParserRULE_limit_offset_clause) + p.SetState(6315) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 781, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6308) + p.Match(GoogleSQLParserLIMIT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6309) + p.expression(0) + } + { + p.SetState(6310) + p.Match(GoogleSQLParserOFFSET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6311) + p.expression(0) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6313) + p.Match(GoogleSQLParserLIMIT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6314) + p.expression(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_having_or_group_by_modifierContext is an interface to support dynamic dispatch. +type IOpt_having_or_group_by_modifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HAVING_SYMBOL() antlr.TerminalNode + MAX_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + MIN_SYMBOL() antlr.TerminalNode + Group_by_clause_prefix() IGroup_by_clause_prefixContext + + // IsOpt_having_or_group_by_modifierContext differentiates from other interfaces. + IsOpt_having_or_group_by_modifierContext() +} + +type Opt_having_or_group_by_modifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_having_or_group_by_modifierContext() *Opt_having_or_group_by_modifierContext { + var p = new(Opt_having_or_group_by_modifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_having_or_group_by_modifier + return p +} + +func InitEmptyOpt_having_or_group_by_modifierContext(p *Opt_having_or_group_by_modifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_having_or_group_by_modifier +} + +func (*Opt_having_or_group_by_modifierContext) IsOpt_having_or_group_by_modifierContext() {} + +func NewOpt_having_or_group_by_modifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_having_or_group_by_modifierContext { + var p = new(Opt_having_or_group_by_modifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_having_or_group_by_modifier + + return p +} + +func (s *Opt_having_or_group_by_modifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_having_or_group_by_modifierContext) HAVING_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserHAVING_SYMBOL, 0) +} + +func (s *Opt_having_or_group_by_modifierContext) MAX_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMAX_SYMBOL, 0) +} + +func (s *Opt_having_or_group_by_modifierContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Opt_having_or_group_by_modifierContext) MIN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMIN_SYMBOL, 0) +} + +func (s *Opt_having_or_group_by_modifierContext) Group_by_clause_prefix() IGroup_by_clause_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_by_clause_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGroup_by_clause_prefixContext) +} + +func (s *Opt_having_or_group_by_modifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_having_or_group_by_modifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_having_or_group_by_modifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_having_or_group_by_modifier(s) + } +} + +func (s *Opt_having_or_group_by_modifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_having_or_group_by_modifier(s) + } +} + +func (s *Opt_having_or_group_by_modifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_having_or_group_by_modifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_having_or_group_by_modifier() (localctx IOpt_having_or_group_by_modifierContext) { + localctx = NewOpt_having_or_group_by_modifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1058, GoogleSQLParserRULE_opt_having_or_group_by_modifier) + p.SetState(6325) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 782, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6317) + p.Match(GoogleSQLParserHAVING_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6318) + p.Match(GoogleSQLParserMAX_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6319) + p.expression(0) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6320) + p.Match(GoogleSQLParserHAVING_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6321) + p.Match(GoogleSQLParserMIN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6322) + p.expression(0) + } + { + p.SetState(6323) + p.Group_by_clause_prefix() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGroup_by_clause_prefixContext is an interface to support dynamic dispatch. +type IGroup_by_clause_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Group_by_preamble() IGroup_by_preambleContext + AllGrouping_item() []IGrouping_itemContext + Grouping_item(i int) IGrouping_itemContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsGroup_by_clause_prefixContext differentiates from other interfaces. + IsGroup_by_clause_prefixContext() +} + +type Group_by_clause_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGroup_by_clause_prefixContext() *Group_by_clause_prefixContext { + var p = new(Group_by_clause_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_group_by_clause_prefix + return p +} + +func InitEmptyGroup_by_clause_prefixContext(p *Group_by_clause_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_group_by_clause_prefix +} + +func (*Group_by_clause_prefixContext) IsGroup_by_clause_prefixContext() {} + +func NewGroup_by_clause_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Group_by_clause_prefixContext { + var p = new(Group_by_clause_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_group_by_clause_prefix + + return p +} + +func (s *Group_by_clause_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Group_by_clause_prefixContext) Group_by_preamble() IGroup_by_preambleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_by_preambleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGroup_by_preambleContext) +} + +func (s *Group_by_clause_prefixContext) AllGrouping_item() []IGrouping_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGrouping_itemContext); ok { + len++ + } + } + + tst := make([]IGrouping_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGrouping_itemContext); ok { + tst[i] = t.(IGrouping_itemContext) + i++ + } + } + + return tst +} + +func (s *Group_by_clause_prefixContext) Grouping_item(i int) IGrouping_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrouping_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGrouping_itemContext) +} + +func (s *Group_by_clause_prefixContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Group_by_clause_prefixContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Group_by_clause_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Group_by_clause_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Group_by_clause_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGroup_by_clause_prefix(s) + } +} + +func (s *Group_by_clause_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGroup_by_clause_prefix(s) + } +} + +func (s *Group_by_clause_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGroup_by_clause_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Group_by_clause_prefix() (localctx IGroup_by_clause_prefixContext) { + localctx = NewGroup_by_clause_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1060, GoogleSQLParserRULE_group_by_clause_prefix) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6327) + p.Group_by_preamble() + } + { + p.SetState(6328) + p.Grouping_item() + } + p.SetState(6333) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 783, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(6329) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6330) + p.Grouping_item() + } + + } + p.SetState(6335) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 783, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGroup_by_preambleContext is an interface to support dynamic dispatch. +type IGroup_by_preambleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GROUP_SYMBOL() antlr.TerminalNode + BY_SYMBOL() antlr.TerminalNode + Hint() IHintContext + Opt_and_order() IOpt_and_orderContext + + // IsGroup_by_preambleContext differentiates from other interfaces. + IsGroup_by_preambleContext() +} + +type Group_by_preambleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGroup_by_preambleContext() *Group_by_preambleContext { + var p = new(Group_by_preambleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_group_by_preamble + return p +} + +func InitEmptyGroup_by_preambleContext(p *Group_by_preambleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_group_by_preamble +} + +func (*Group_by_preambleContext) IsGroup_by_preambleContext() {} + +func NewGroup_by_preambleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Group_by_preambleContext { + var p = new(Group_by_preambleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_group_by_preamble + + return p +} + +func (s *Group_by_preambleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Group_by_preambleContext) GROUP_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserGROUP_SYMBOL, 0) +} + +func (s *Group_by_preambleContext) BY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBY_SYMBOL, 0) +} + +func (s *Group_by_preambleContext) Hint() IHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintContext) +} + +func (s *Group_by_preambleContext) Opt_and_order() IOpt_and_orderContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_and_orderContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_and_orderContext) +} + +func (s *Group_by_preambleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Group_by_preambleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Group_by_preambleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGroup_by_preamble(s) + } +} + +func (s *Group_by_preambleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGroup_by_preamble(s) + } +} + +func (s *Group_by_preambleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGroup_by_preamble(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Group_by_preamble() (localctx IGroup_by_preambleContext) { + localctx = NewGroup_by_preambleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1062, GoogleSQLParserRULE_group_by_preamble) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6336) + p.Match(GoogleSQLParserGROUP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6338) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(6337) + p.Hint() + } + + } + p.SetState(6341) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAND_SYMBOL { + { + p.SetState(6340) + p.Opt_and_order() + } + + } + { + p.SetState(6343) + p.Match(GoogleSQLParserBY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_and_orderContext is an interface to support dynamic dispatch. +type IOpt_and_orderContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AND_SYMBOL() antlr.TerminalNode + ORDER_SYMBOL() antlr.TerminalNode + + // IsOpt_and_orderContext differentiates from other interfaces. + IsOpt_and_orderContext() +} + +type Opt_and_orderContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_and_orderContext() *Opt_and_orderContext { + var p = new(Opt_and_orderContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_and_order + return p +} + +func InitEmptyOpt_and_orderContext(p *Opt_and_orderContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_and_order +} + +func (*Opt_and_orderContext) IsOpt_and_orderContext() {} + +func NewOpt_and_orderContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_and_orderContext { + var p = new(Opt_and_orderContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_and_order + + return p +} + +func (s *Opt_and_orderContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_and_orderContext) AND_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAND_SYMBOL, 0) +} + +func (s *Opt_and_orderContext) ORDER_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserORDER_SYMBOL, 0) +} + +func (s *Opt_and_orderContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_and_orderContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_and_orderContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_and_order(s) + } +} + +func (s *Opt_and_orderContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_and_order(s) + } +} + +func (s *Opt_and_orderContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_and_order(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_and_order() (localctx IOpt_and_orderContext) { + localctx = NewOpt_and_orderContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1064, GoogleSQLParserRULE_opt_and_order) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6345) + p.Match(GoogleSQLParserAND_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6346) + p.Match(GoogleSQLParserORDER_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHintContext is an interface to support dynamic dispatch. +type IHintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AT_SYMBOL() antlr.TerminalNode + Integer_literal() IInteger_literalContext + Hint_with_body() IHint_with_bodyContext + + // IsHintContext differentiates from other interfaces. + IsHintContext() +} + +type HintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHintContext() *HintContext { + var p = new(HintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_hint + return p +} + +func InitEmptyHintContext(p *HintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_hint +} + +func (*HintContext) IsHintContext() {} + +func NewHintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HintContext { + var p = new(HintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_hint + + return p +} + +func (s *HintContext) GetParser() antlr.Parser { return s.parser } + +func (s *HintContext) AT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAT_SYMBOL, 0) +} + +func (s *HintContext) Integer_literal() IInteger_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInteger_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInteger_literalContext) +} + +func (s *HintContext) Hint_with_body() IHint_with_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHint_with_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHint_with_bodyContext) +} + +func (s *HintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *HintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterHint(s) + } +} + +func (s *HintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitHint(s) + } +} + +func (s *HintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitHint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Hint() (localctx IHintContext) { + localctx = NewHintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1066, GoogleSQLParserRULE_hint) + p.SetState(6351) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 786, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6348) + p.Match(GoogleSQLParserAT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6349) + p.Integer_literal() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6350) + p.Hint_with_body() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHint_with_bodyContext is an interface to support dynamic dispatch. +type IHint_with_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Hint_with_body_prefix() IHint_with_body_prefixContext + RC_BRACKET_SYMBOL() antlr.TerminalNode + + // IsHint_with_bodyContext differentiates from other interfaces. + IsHint_with_bodyContext() +} + +type Hint_with_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHint_with_bodyContext() *Hint_with_bodyContext { + var p = new(Hint_with_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_hint_with_body + return p +} + +func InitEmptyHint_with_bodyContext(p *Hint_with_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_hint_with_body +} + +func (*Hint_with_bodyContext) IsHint_with_bodyContext() {} + +func NewHint_with_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hint_with_bodyContext { + var p = new(Hint_with_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_hint_with_body + + return p +} + +func (s *Hint_with_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hint_with_bodyContext) Hint_with_body_prefix() IHint_with_body_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHint_with_body_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHint_with_body_prefixContext) +} + +func (s *Hint_with_bodyContext) RC_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRC_BRACKET_SYMBOL, 0) +} + +func (s *Hint_with_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hint_with_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hint_with_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterHint_with_body(s) + } +} + +func (s *Hint_with_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitHint_with_body(s) + } +} + +func (s *Hint_with_bodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitHint_with_body(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Hint_with_body() (localctx IHint_with_bodyContext) { + localctx = NewHint_with_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1068, GoogleSQLParserRULE_hint_with_body) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6353) + p.Hint_with_body_prefix() + } + { + p.SetState(6354) + p.Match(GoogleSQLParserRC_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHint_with_body_prefixContext is an interface to support dynamic dispatch. +type IHint_with_body_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllAT_SYMBOL() []antlr.TerminalNode + AT_SYMBOL(i int) antlr.TerminalNode + LC_BRACKET_SYMBOL() antlr.TerminalNode + AllHint_entry() []IHint_entryContext + Hint_entry(i int) IHint_entryContext + Integer_literal() IInteger_literalContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsHint_with_body_prefixContext differentiates from other interfaces. + IsHint_with_body_prefixContext() +} + +type Hint_with_body_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHint_with_body_prefixContext() *Hint_with_body_prefixContext { + var p = new(Hint_with_body_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_hint_with_body_prefix + return p +} + +func InitEmptyHint_with_body_prefixContext(p *Hint_with_body_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_hint_with_body_prefix +} + +func (*Hint_with_body_prefixContext) IsHint_with_body_prefixContext() {} + +func NewHint_with_body_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hint_with_body_prefixContext { + var p = new(Hint_with_body_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_hint_with_body_prefix + + return p +} + +func (s *Hint_with_body_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hint_with_body_prefixContext) AllAT_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserAT_SYMBOL) +} + +func (s *Hint_with_body_prefixContext) AT_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAT_SYMBOL, i) +} + +func (s *Hint_with_body_prefixContext) LC_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLC_BRACKET_SYMBOL, 0) +} + +func (s *Hint_with_body_prefixContext) AllHint_entry() []IHint_entryContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IHint_entryContext); ok { + len++ + } + } + + tst := make([]IHint_entryContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IHint_entryContext); ok { + tst[i] = t.(IHint_entryContext) + i++ + } + } + + return tst +} + +func (s *Hint_with_body_prefixContext) Hint_entry(i int) IHint_entryContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHint_entryContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IHint_entryContext) +} + +func (s *Hint_with_body_prefixContext) Integer_literal() IInteger_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInteger_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInteger_literalContext) +} + +func (s *Hint_with_body_prefixContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Hint_with_body_prefixContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Hint_with_body_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hint_with_body_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hint_with_body_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterHint_with_body_prefix(s) + } +} + +func (s *Hint_with_body_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitHint_with_body_prefix(s) + } +} + +func (s *Hint_with_body_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitHint_with_body_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Hint_with_body_prefix() (localctx IHint_with_body_prefixContext) { + localctx = NewHint_with_body_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1070, GoogleSQLParserRULE_hint_with_body_prefix) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6356) + p.Match(GoogleSQLParserAT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6360) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserINTEGER_LITERAL { + { + p.SetState(6357) + p.Integer_literal() + } + { + p.SetState(6358) + p.Match(GoogleSQLParserAT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6362) + p.Match(GoogleSQLParserLC_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6363) + p.Hint_entry() + } + p.SetState(6368) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(6364) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6365) + p.Hint_entry() + } + + p.SetState(6370) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHint_entryContext is an interface to support dynamic dispatch. +type IHint_entryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllIdentifier_in_hints() []IIdentifier_in_hintsContext + Identifier_in_hints(i int) IIdentifier_in_hintsContext + EQUAL_OPERATOR() antlr.TerminalNode + Expression() IExpressionContext + DOT_SYMBOL() antlr.TerminalNode + + // IsHint_entryContext differentiates from other interfaces. + IsHint_entryContext() +} + +type Hint_entryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHint_entryContext() *Hint_entryContext { + var p = new(Hint_entryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_hint_entry + return p +} + +func InitEmptyHint_entryContext(p *Hint_entryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_hint_entry +} + +func (*Hint_entryContext) IsHint_entryContext() {} + +func NewHint_entryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hint_entryContext { + var p = new(Hint_entryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_hint_entry + + return p +} + +func (s *Hint_entryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hint_entryContext) AllIdentifier_in_hints() []IIdentifier_in_hintsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifier_in_hintsContext); ok { + len++ + } + } + + tst := make([]IIdentifier_in_hintsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifier_in_hintsContext); ok { + tst[i] = t.(IIdentifier_in_hintsContext) + i++ + } + } + + return tst +} + +func (s *Hint_entryContext) Identifier_in_hints(i int) IIdentifier_in_hintsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifier_in_hintsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifier_in_hintsContext) +} + +func (s *Hint_entryContext) EQUAL_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEQUAL_OPERATOR, 0) +} + +func (s *Hint_entryContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Hint_entryContext) DOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDOT_SYMBOL, 0) +} + +func (s *Hint_entryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hint_entryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hint_entryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterHint_entry(s) + } +} + +func (s *Hint_entryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitHint_entry(s) + } +} + +func (s *Hint_entryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitHint_entry(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Hint_entry() (localctx IHint_entryContext) { + localctx = NewHint_entryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1072, GoogleSQLParserRULE_hint_entry) + p.SetState(6381) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 789, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6371) + p.Identifier_in_hints() + } + { + p.SetState(6372) + p.Match(GoogleSQLParserEQUAL_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6373) + p.expression(0) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6375) + p.Identifier_in_hints() + } + { + p.SetState(6376) + p.Match(GoogleSQLParserDOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6377) + p.Identifier_in_hints() + } + { + p.SetState(6378) + p.Match(GoogleSQLParserEQUAL_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6379) + p.expression(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentifier_in_hintsContext is an interface to support dynamic dispatch. +type IIdentifier_in_hintsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Extra_identifier_in_hints_name() IExtra_identifier_in_hints_nameContext + + // IsIdentifier_in_hintsContext differentiates from other interfaces. + IsIdentifier_in_hintsContext() +} + +type Identifier_in_hintsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentifier_in_hintsContext() *Identifier_in_hintsContext { + var p = new(Identifier_in_hintsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_identifier_in_hints + return p +} + +func InitEmptyIdentifier_in_hintsContext(p *Identifier_in_hintsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_identifier_in_hints +} + +func (*Identifier_in_hintsContext) IsIdentifier_in_hintsContext() {} + +func NewIdentifier_in_hintsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Identifier_in_hintsContext { + var p = new(Identifier_in_hintsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_identifier_in_hints + + return p +} + +func (s *Identifier_in_hintsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Identifier_in_hintsContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Identifier_in_hintsContext) Extra_identifier_in_hints_name() IExtra_identifier_in_hints_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtra_identifier_in_hints_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExtra_identifier_in_hints_nameContext) +} + +func (s *Identifier_in_hintsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Identifier_in_hintsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Identifier_in_hintsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterIdentifier_in_hints(s) + } +} + +func (s *Identifier_in_hintsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitIdentifier_in_hints(s) + } +} + +func (s *Identifier_in_hintsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitIdentifier_in_hints(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Identifier_in_hints() (localctx IIdentifier_in_hintsContext) { + localctx = NewIdentifier_in_hintsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1074, GoogleSQLParserRULE_identifier_in_hints) + p.SetState(6385) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6383) + p.Identifier() + } + + case GoogleSQLParserHASH_SYMBOL, GoogleSQLParserPROTO_SYMBOL, GoogleSQLParserPARTITION_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6384) + p.Extra_identifier_in_hints_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExtra_identifier_in_hints_nameContext is an interface to support dynamic dispatch. +type IExtra_identifier_in_hints_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HASH_SYMBOL() antlr.TerminalNode + PROTO_SYMBOL() antlr.TerminalNode + PARTITION_SYMBOL() antlr.TerminalNode + + // IsExtra_identifier_in_hints_nameContext differentiates from other interfaces. + IsExtra_identifier_in_hints_nameContext() +} + +type Extra_identifier_in_hints_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExtra_identifier_in_hints_nameContext() *Extra_identifier_in_hints_nameContext { + var p = new(Extra_identifier_in_hints_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_extra_identifier_in_hints_name + return p +} + +func InitEmptyExtra_identifier_in_hints_nameContext(p *Extra_identifier_in_hints_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_extra_identifier_in_hints_name +} + +func (*Extra_identifier_in_hints_nameContext) IsExtra_identifier_in_hints_nameContext() {} + +func NewExtra_identifier_in_hints_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Extra_identifier_in_hints_nameContext { + var p = new(Extra_identifier_in_hints_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_extra_identifier_in_hints_name + + return p +} + +func (s *Extra_identifier_in_hints_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Extra_identifier_in_hints_nameContext) HASH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserHASH_SYMBOL, 0) +} + +func (s *Extra_identifier_in_hints_nameContext) PROTO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPROTO_SYMBOL, 0) +} + +func (s *Extra_identifier_in_hints_nameContext) PARTITION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPARTITION_SYMBOL, 0) +} + +func (s *Extra_identifier_in_hints_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Extra_identifier_in_hints_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Extra_identifier_in_hints_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterExtra_identifier_in_hints_name(s) + } +} + +func (s *Extra_identifier_in_hints_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitExtra_identifier_in_hints_name(s) + } +} + +func (s *Extra_identifier_in_hints_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitExtra_identifier_in_hints_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Extra_identifier_in_hints_name() (localctx IExtra_identifier_in_hints_nameContext) { + localctx = NewExtra_identifier_in_hints_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1076, GoogleSQLParserRULE_extra_identifier_in_hints_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6387) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-310)) & ^0x3f) == 0 && ((int64(1)<<(_la-310))&7) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrouping_itemContext is an interface to support dynamic dispatch. +type IGrouping_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + RR_BRACKET_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + Opt_as_alias_with_required_as() IOpt_as_alias_with_required_asContext + Opt_grouping_item_order() IOpt_grouping_item_orderContext + Rollup_list() IRollup_listContext + Cube_list() ICube_listContext + Grouping_set_list() IGrouping_set_listContext + + // IsGrouping_itemContext differentiates from other interfaces. + IsGrouping_itemContext() +} + +type Grouping_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrouping_itemContext() *Grouping_itemContext { + var p = new(Grouping_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_grouping_item + return p +} + +func InitEmptyGrouping_itemContext(p *Grouping_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_grouping_item +} + +func (*Grouping_itemContext) IsGrouping_itemContext() {} + +func NewGrouping_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grouping_itemContext { + var p = new(Grouping_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_grouping_item + + return p +} + +func (s *Grouping_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grouping_itemContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Grouping_itemContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Grouping_itemContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Grouping_itemContext) Opt_as_alias_with_required_as() IOpt_as_alias_with_required_asContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_as_alias_with_required_asContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_as_alias_with_required_asContext) +} + +func (s *Grouping_itemContext) Opt_grouping_item_order() IOpt_grouping_item_orderContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_grouping_item_orderContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_grouping_item_orderContext) +} + +func (s *Grouping_itemContext) Rollup_list() IRollup_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollup_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRollup_listContext) +} + +func (s *Grouping_itemContext) Cube_list() ICube_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICube_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICube_listContext) +} + +func (s *Grouping_itemContext) Grouping_set_list() IGrouping_set_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrouping_set_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrouping_set_listContext) +} + +func (s *Grouping_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grouping_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grouping_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGrouping_item(s) + } +} + +func (s *Grouping_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGrouping_item(s) + } +} + +func (s *Grouping_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGrouping_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Grouping_item() (localctx IGrouping_itemContext) { + localctx = NewGrouping_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1078, GoogleSQLParserRULE_grouping_item) + p.SetState(6407) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 793, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6389) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6390) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6391) + p.expression(0) + } + p.SetState(6393) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 791, p.GetParserRuleContext()) == 1 { + { + p.SetState(6392) + p.Opt_as_alias_with_required_as() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6396) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 792, p.GetParserRuleContext()) == 1 { + { + p.SetState(6395) + p.Opt_grouping_item_order() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6398) + p.Rollup_list() + } + { + p.SetState(6399) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6401) + p.Cube_list() + } + { + p.SetState(6402) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6404) + p.Grouping_set_list() + } + { + p.SetState(6405) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrouping_set_listContext is an interface to support dynamic dispatch. +type IGrouping_set_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GROUPING_SYMBOL() antlr.TerminalNode + SETS_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + AllGrouping_set() []IGrouping_setContext + Grouping_set(i int) IGrouping_setContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsGrouping_set_listContext differentiates from other interfaces. + IsGrouping_set_listContext() +} + +type Grouping_set_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrouping_set_listContext() *Grouping_set_listContext { + var p = new(Grouping_set_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_grouping_set_list + return p +} + +func InitEmptyGrouping_set_listContext(p *Grouping_set_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_grouping_set_list +} + +func (*Grouping_set_listContext) IsGrouping_set_listContext() {} + +func NewGrouping_set_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grouping_set_listContext { + var p = new(Grouping_set_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_grouping_set_list + + return p +} + +func (s *Grouping_set_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grouping_set_listContext) GROUPING_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserGROUPING_SYMBOL, 0) +} + +func (s *Grouping_set_listContext) SETS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSETS_SYMBOL, 0) +} + +func (s *Grouping_set_listContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Grouping_set_listContext) AllGrouping_set() []IGrouping_setContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGrouping_setContext); ok { + len++ + } + } + + tst := make([]IGrouping_setContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGrouping_setContext); ok { + tst[i] = t.(IGrouping_setContext) + i++ + } + } + + return tst +} + +func (s *Grouping_set_listContext) Grouping_set(i int) IGrouping_setContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrouping_setContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGrouping_setContext) +} + +func (s *Grouping_set_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Grouping_set_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Grouping_set_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grouping_set_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grouping_set_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGrouping_set_list(s) + } +} + +func (s *Grouping_set_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGrouping_set_list(s) + } +} + +func (s *Grouping_set_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGrouping_set_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Grouping_set_list() (localctx IGrouping_set_listContext) { + localctx = NewGrouping_set_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1080, GoogleSQLParserRULE_grouping_set_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6409) + p.Match(GoogleSQLParserGROUPING_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6410) + p.Match(GoogleSQLParserSETS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6411) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6412) + p.Grouping_set() + } + p.SetState(6417) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(6413) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6414) + p.Grouping_set() + } + + p.SetState(6419) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrouping_setContext is an interface to support dynamic dispatch. +type IGrouping_setContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + RR_BRACKET_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + Rollup_list() IRollup_listContext + Cube_list() ICube_listContext + + // IsGrouping_setContext differentiates from other interfaces. + IsGrouping_setContext() +} + +type Grouping_setContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrouping_setContext() *Grouping_setContext { + var p = new(Grouping_setContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_grouping_set + return p +} + +func InitEmptyGrouping_setContext(p *Grouping_setContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_grouping_set +} + +func (*Grouping_setContext) IsGrouping_setContext() {} + +func NewGrouping_setContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grouping_setContext { + var p = new(Grouping_setContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_grouping_set + + return p +} + +func (s *Grouping_setContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grouping_setContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Grouping_setContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Grouping_setContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Grouping_setContext) Rollup_list() IRollup_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollup_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRollup_listContext) +} + +func (s *Grouping_setContext) Cube_list() ICube_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICube_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICube_listContext) +} + +func (s *Grouping_setContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grouping_setContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grouping_setContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGrouping_set(s) + } +} + +func (s *Grouping_setContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGrouping_set(s) + } +} + +func (s *Grouping_setContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGrouping_set(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Grouping_set() (localctx IGrouping_setContext) { + localctx = NewGrouping_setContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1082, GoogleSQLParserRULE_grouping_set) + p.SetState(6429) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 795, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6420) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6421) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6422) + p.expression(0) + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6423) + p.Rollup_list() + } + { + p.SetState(6424) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6426) + p.Cube_list() + } + { + p.SetState(6427) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICube_listContext is an interface to support dynamic dispatch. +type ICube_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CUBE_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + + // IsCube_listContext differentiates from other interfaces. + IsCube_listContext() +} + +type Cube_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCube_listContext() *Cube_listContext { + var p = new(Cube_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_cube_list + return p +} + +func InitEmptyCube_listContext(p *Cube_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_cube_list +} + +func (*Cube_listContext) IsCube_listContext() {} + +func NewCube_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cube_listContext { + var p = new(Cube_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_cube_list + + return p +} + +func (s *Cube_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cube_listContext) CUBE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCUBE_SYMBOL, 0) +} + +func (s *Cube_listContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Cube_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Cube_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Cube_listContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Cube_listContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Cube_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cube_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cube_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCube_list(s) + } +} + +func (s *Cube_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCube_list(s) + } +} + +func (s *Cube_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCube_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Cube_list() (localctx ICube_listContext) { + localctx = NewCube_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1084, GoogleSQLParserRULE_cube_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6431) + p.Match(GoogleSQLParserCUBE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6432) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6437) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(6433) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6434) + p.expression(0) + } + + p.SetState(6439) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRollup_listContext is an interface to support dynamic dispatch. +type IRollup_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROLLUP_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsRollup_listContext differentiates from other interfaces. + IsRollup_listContext() +} + +type Rollup_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRollup_listContext() *Rollup_listContext { + var p = new(Rollup_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_rollup_list + return p +} + +func InitEmptyRollup_listContext(p *Rollup_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_rollup_list +} + +func (*Rollup_listContext) IsRollup_listContext() {} + +func NewRollup_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rollup_listContext { + var p = new(Rollup_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_rollup_list + + return p +} + +func (s *Rollup_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rollup_listContext) ROLLUP_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserROLLUP_SYMBOL, 0) +} + +func (s *Rollup_listContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Rollup_listContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Rollup_listContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Rollup_listContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Rollup_listContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Rollup_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rollup_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rollup_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterRollup_list(s) + } +} + +func (s *Rollup_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitRollup_list(s) + } +} + +func (s *Rollup_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitRollup_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Rollup_list() (localctx IRollup_listContext) { + localctx = NewRollup_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1086, GoogleSQLParserRULE_rollup_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6440) + p.Match(GoogleSQLParserROLLUP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6441) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6442) + p.expression(0) + } + p.SetState(6447) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(6443) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6444) + p.expression(0) + } + + p.SetState(6449) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_as_alias_with_required_asContext is an interface to support dynamic dispatch. +type IOpt_as_alias_with_required_asContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AS_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsOpt_as_alias_with_required_asContext differentiates from other interfaces. + IsOpt_as_alias_with_required_asContext() +} + +type Opt_as_alias_with_required_asContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_as_alias_with_required_asContext() *Opt_as_alias_with_required_asContext { + var p = new(Opt_as_alias_with_required_asContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_as_alias_with_required_as + return p +} + +func InitEmptyOpt_as_alias_with_required_asContext(p *Opt_as_alias_with_required_asContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_as_alias_with_required_as +} + +func (*Opt_as_alias_with_required_asContext) IsOpt_as_alias_with_required_asContext() {} + +func NewOpt_as_alias_with_required_asContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_as_alias_with_required_asContext { + var p = new(Opt_as_alias_with_required_asContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_as_alias_with_required_as + + return p +} + +func (s *Opt_as_alias_with_required_asContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_as_alias_with_required_asContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Opt_as_alias_with_required_asContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Opt_as_alias_with_required_asContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_as_alias_with_required_asContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_as_alias_with_required_asContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_as_alias_with_required_as(s) + } +} + +func (s *Opt_as_alias_with_required_asContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_as_alias_with_required_as(s) + } +} + +func (s *Opt_as_alias_with_required_asContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_as_alias_with_required_as(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_as_alias_with_required_as() (localctx IOpt_as_alias_with_required_asContext) { + localctx = NewOpt_as_alias_with_required_asContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1088, GoogleSQLParserRULE_opt_as_alias_with_required_as) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6450) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6451) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_grouping_item_orderContext is an interface to support dynamic dispatch. +type IOpt_grouping_item_orderContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Opt_selection_item_order() IOpt_selection_item_orderContext + Null_order() INull_orderContext + + // IsOpt_grouping_item_orderContext differentiates from other interfaces. + IsOpt_grouping_item_orderContext() +} + +type Opt_grouping_item_orderContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_grouping_item_orderContext() *Opt_grouping_item_orderContext { + var p = new(Opt_grouping_item_orderContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_grouping_item_order + return p +} + +func InitEmptyOpt_grouping_item_orderContext(p *Opt_grouping_item_orderContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_grouping_item_order +} + +func (*Opt_grouping_item_orderContext) IsOpt_grouping_item_orderContext() {} + +func NewOpt_grouping_item_orderContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_grouping_item_orderContext { + var p = new(Opt_grouping_item_orderContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_grouping_item_order + + return p +} + +func (s *Opt_grouping_item_orderContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_grouping_item_orderContext) Opt_selection_item_order() IOpt_selection_item_orderContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_selection_item_orderContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_selection_item_orderContext) +} + +func (s *Opt_grouping_item_orderContext) Null_order() INull_orderContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INull_orderContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INull_orderContext) +} + +func (s *Opt_grouping_item_orderContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_grouping_item_orderContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_grouping_item_orderContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_grouping_item_order(s) + } +} + +func (s *Opt_grouping_item_orderContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_grouping_item_order(s) + } +} + +func (s *Opt_grouping_item_orderContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_grouping_item_order(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_grouping_item_order() (localctx IOpt_grouping_item_orderContext) { + localctx = NewOpt_grouping_item_orderContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1090, GoogleSQLParserRULE_opt_grouping_item_order) + p.SetState(6455) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserASC_SYMBOL, GoogleSQLParserDESC_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6453) + p.Opt_selection_item_order() + } + + case GoogleSQLParserNULLS_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6454) + p.Null_order() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_selection_item_orderContext is an interface to support dynamic dispatch. +type IOpt_selection_item_orderContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Asc_or_desc() IAsc_or_descContext + Null_order() INull_orderContext + + // IsOpt_selection_item_orderContext differentiates from other interfaces. + IsOpt_selection_item_orderContext() +} + +type Opt_selection_item_orderContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_selection_item_orderContext() *Opt_selection_item_orderContext { + var p = new(Opt_selection_item_orderContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_selection_item_order + return p +} + +func InitEmptyOpt_selection_item_orderContext(p *Opt_selection_item_orderContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_selection_item_order +} + +func (*Opt_selection_item_orderContext) IsOpt_selection_item_orderContext() {} + +func NewOpt_selection_item_orderContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_selection_item_orderContext { + var p = new(Opt_selection_item_orderContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_selection_item_order + + return p +} + +func (s *Opt_selection_item_orderContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_selection_item_orderContext) Asc_or_desc() IAsc_or_descContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAsc_or_descContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAsc_or_descContext) +} + +func (s *Opt_selection_item_orderContext) Null_order() INull_orderContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INull_orderContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INull_orderContext) +} + +func (s *Opt_selection_item_orderContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_selection_item_orderContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_selection_item_orderContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_selection_item_order(s) + } +} + +func (s *Opt_selection_item_orderContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_selection_item_order(s) + } +} + +func (s *Opt_selection_item_orderContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_selection_item_order(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_selection_item_order() (localctx IOpt_selection_item_orderContext) { + localctx = NewOpt_selection_item_orderContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1092, GoogleSQLParserRULE_opt_selection_item_order) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6457) + p.Asc_or_desc() + } + p.SetState(6459) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 799, p.GetParserRuleContext()) == 1 { + { + p.SetState(6458) + p.Null_order() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAsc_or_descContext is an interface to support dynamic dispatch. +type IAsc_or_descContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ASC_SYMBOL() antlr.TerminalNode + DESC_SYMBOL() antlr.TerminalNode + + // IsAsc_or_descContext differentiates from other interfaces. + IsAsc_or_descContext() +} + +type Asc_or_descContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAsc_or_descContext() *Asc_or_descContext { + var p = new(Asc_or_descContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_asc_or_desc + return p +} + +func InitEmptyAsc_or_descContext(p *Asc_or_descContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_asc_or_desc +} + +func (*Asc_or_descContext) IsAsc_or_descContext() {} + +func NewAsc_or_descContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Asc_or_descContext { + var p = new(Asc_or_descContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_asc_or_desc + + return p +} + +func (s *Asc_or_descContext) GetParser() antlr.Parser { return s.parser } + +func (s *Asc_or_descContext) ASC_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserASC_SYMBOL, 0) +} + +func (s *Asc_or_descContext) DESC_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDESC_SYMBOL, 0) +} + +func (s *Asc_or_descContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Asc_or_descContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Asc_or_descContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterAsc_or_desc(s) + } +} + +func (s *Asc_or_descContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitAsc_or_desc(s) + } +} + +func (s *Asc_or_descContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitAsc_or_desc(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Asc_or_desc() (localctx IAsc_or_descContext) { + localctx = NewAsc_or_descContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1094, GoogleSQLParserRULE_asc_or_desc) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6461) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserASC_SYMBOL || _la == GoogleSQLParserDESC_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INull_orderContext is an interface to support dynamic dispatch. +type INull_orderContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NULLS_SYMBOL() antlr.TerminalNode + FIRST_SYMBOL() antlr.TerminalNode + LAST_SYMBOL() antlr.TerminalNode + + // IsNull_orderContext differentiates from other interfaces. + IsNull_orderContext() +} + +type Null_orderContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNull_orderContext() *Null_orderContext { + var p = new(Null_orderContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_null_order + return p +} + +func InitEmptyNull_orderContext(p *Null_orderContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_null_order +} + +func (*Null_orderContext) IsNull_orderContext() {} + +func NewNull_orderContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Null_orderContext { + var p = new(Null_orderContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_null_order + + return p +} + +func (s *Null_orderContext) GetParser() antlr.Parser { return s.parser } + +func (s *Null_orderContext) NULLS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNULLS_SYMBOL, 0) +} + +func (s *Null_orderContext) FIRST_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFIRST_SYMBOL, 0) +} + +func (s *Null_orderContext) LAST_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLAST_SYMBOL, 0) +} + +func (s *Null_orderContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Null_orderContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Null_orderContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterNull_order(s) + } +} + +func (s *Null_orderContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitNull_order(s) + } +} + +func (s *Null_orderContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitNull_order(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Null_order() (localctx INull_orderContext) { + localctx = NewNull_orderContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1096, GoogleSQLParserRULE_null_order) + p.SetState(6467) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 800, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6463) + p.Match(GoogleSQLParserNULLS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6464) + p.Match(GoogleSQLParserFIRST_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6465) + p.Match(GoogleSQLParserNULLS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6466) + p.Match(GoogleSQLParserLAST_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunction_name_from_keywordContext is an interface to support dynamic dispatch. +type IFunction_name_from_keywordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IF_SYMBOL() antlr.TerminalNode + GROUPING_SYMBOL() antlr.TerminalNode + LEFT_SYMBOL() antlr.TerminalNode + RIGHT_SYMBOL() antlr.TerminalNode + COLLATE_SYMBOL() antlr.TerminalNode + RANGE_SYMBOL() antlr.TerminalNode + + // IsFunction_name_from_keywordContext differentiates from other interfaces. + IsFunction_name_from_keywordContext() +} + +type Function_name_from_keywordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_name_from_keywordContext() *Function_name_from_keywordContext { + var p = new(Function_name_from_keywordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_function_name_from_keyword + return p +} + +func InitEmptyFunction_name_from_keywordContext(p *Function_name_from_keywordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_function_name_from_keyword +} + +func (*Function_name_from_keywordContext) IsFunction_name_from_keywordContext() {} + +func NewFunction_name_from_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_name_from_keywordContext { + var p = new(Function_name_from_keywordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_function_name_from_keyword + + return p +} + +func (s *Function_name_from_keywordContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_name_from_keywordContext) IF_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIF_SYMBOL, 0) +} + +func (s *Function_name_from_keywordContext) GROUPING_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserGROUPING_SYMBOL, 0) +} + +func (s *Function_name_from_keywordContext) LEFT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLEFT_SYMBOL, 0) +} + +func (s *Function_name_from_keywordContext) RIGHT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRIGHT_SYMBOL, 0) +} + +func (s *Function_name_from_keywordContext) COLLATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOLLATE_SYMBOL, 0) +} + +func (s *Function_name_from_keywordContext) RANGE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRANGE_SYMBOL, 0) +} + +func (s *Function_name_from_keywordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_name_from_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_name_from_keywordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterFunction_name_from_keyword(s) + } +} + +func (s *Function_name_from_keywordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitFunction_name_from_keyword(s) + } +} + +func (s *Function_name_from_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitFunction_name_from_keyword(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Function_name_from_keyword() (localctx IFunction_name_from_keywordContext) { + localctx = NewFunction_name_from_keywordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1098, GoogleSQLParserRULE_function_name_from_keyword) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6469) + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-77)) & ^0x3f) == 0 && ((int64(1)<<(_la-77))&4398046527489) != 0) || ((int64((_la-303)) & ^0x3f) == 0 && ((int64(1)<<(_la-303))&7) != 0)) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReplace_fields_expressionContext is an interface to support dynamic dispatch. +type IReplace_fields_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Replace_fields_prefix() IReplace_fields_prefixContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsReplace_fields_expressionContext differentiates from other interfaces. + IsReplace_fields_expressionContext() +} + +type Replace_fields_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReplace_fields_expressionContext() *Replace_fields_expressionContext { + var p = new(Replace_fields_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_replace_fields_expression + return p +} + +func InitEmptyReplace_fields_expressionContext(p *Replace_fields_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_replace_fields_expression +} + +func (*Replace_fields_expressionContext) IsReplace_fields_expressionContext() {} + +func NewReplace_fields_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Replace_fields_expressionContext { + var p = new(Replace_fields_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_replace_fields_expression + + return p +} + +func (s *Replace_fields_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Replace_fields_expressionContext) Replace_fields_prefix() IReplace_fields_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReplace_fields_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReplace_fields_prefixContext) +} + +func (s *Replace_fields_expressionContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Replace_fields_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Replace_fields_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Replace_fields_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterReplace_fields_expression(s) + } +} + +func (s *Replace_fields_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitReplace_fields_expression(s) + } +} + +func (s *Replace_fields_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitReplace_fields_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Replace_fields_expression() (localctx IReplace_fields_expressionContext) { + localctx = NewReplace_fields_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1100, GoogleSQLParserRULE_replace_fields_expression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6471) + p.Replace_fields_prefix() + } + { + p.SetState(6472) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReplace_fields_prefixContext is an interface to support dynamic dispatch. +type IReplace_fields_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REPLACE_FIELDS_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + AllReplace_fields_arg() []IReplace_fields_argContext + Replace_fields_arg(i int) IReplace_fields_argContext + + // IsReplace_fields_prefixContext differentiates from other interfaces. + IsReplace_fields_prefixContext() +} + +type Replace_fields_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReplace_fields_prefixContext() *Replace_fields_prefixContext { + var p = new(Replace_fields_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_replace_fields_prefix + return p +} + +func InitEmptyReplace_fields_prefixContext(p *Replace_fields_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_replace_fields_prefix +} + +func (*Replace_fields_prefixContext) IsReplace_fields_prefixContext() {} + +func NewReplace_fields_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Replace_fields_prefixContext { + var p = new(Replace_fields_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_replace_fields_prefix + + return p +} + +func (s *Replace_fields_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Replace_fields_prefixContext) REPLACE_FIELDS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREPLACE_FIELDS_SYMBOL, 0) +} + +func (s *Replace_fields_prefixContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Replace_fields_prefixContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Replace_fields_prefixContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Replace_fields_prefixContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Replace_fields_prefixContext) AllReplace_fields_arg() []IReplace_fields_argContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IReplace_fields_argContext); ok { + len++ + } + } + + tst := make([]IReplace_fields_argContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IReplace_fields_argContext); ok { + tst[i] = t.(IReplace_fields_argContext) + i++ + } + } + + return tst +} + +func (s *Replace_fields_prefixContext) Replace_fields_arg(i int) IReplace_fields_argContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReplace_fields_argContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IReplace_fields_argContext) +} + +func (s *Replace_fields_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Replace_fields_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Replace_fields_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterReplace_fields_prefix(s) + } +} + +func (s *Replace_fields_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitReplace_fields_prefix(s) + } +} + +func (s *Replace_fields_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitReplace_fields_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Replace_fields_prefix() (localctx IReplace_fields_prefixContext) { + localctx = NewReplace_fields_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1102, GoogleSQLParserRULE_replace_fields_prefix) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6474) + p.Match(GoogleSQLParserREPLACE_FIELDS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6475) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6476) + p.expression(0) + } + { + p.SetState(6477) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6478) + p.Replace_fields_arg() + } + p.SetState(6483) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(6479) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6480) + p.Replace_fields_arg() + } + + p.SetState(6485) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReplace_fields_argContext is an interface to support dynamic dispatch. +type IReplace_fields_argContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + AS_SYMBOL() antlr.TerminalNode + Generalized_path_expression() IGeneralized_path_expressionContext + Generalized_extension_path() IGeneralized_extension_pathContext + + // IsReplace_fields_argContext differentiates from other interfaces. + IsReplace_fields_argContext() +} + +type Replace_fields_argContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReplace_fields_argContext() *Replace_fields_argContext { + var p = new(Replace_fields_argContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_replace_fields_arg + return p +} + +func InitEmptyReplace_fields_argContext(p *Replace_fields_argContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_replace_fields_arg +} + +func (*Replace_fields_argContext) IsReplace_fields_argContext() {} + +func NewReplace_fields_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Replace_fields_argContext { + var p = new(Replace_fields_argContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_replace_fields_arg + + return p +} + +func (s *Replace_fields_argContext) GetParser() antlr.Parser { return s.parser } + +func (s *Replace_fields_argContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Replace_fields_argContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Replace_fields_argContext) Generalized_path_expression() IGeneralized_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneralized_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneralized_path_expressionContext) +} + +func (s *Replace_fields_argContext) Generalized_extension_path() IGeneralized_extension_pathContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneralized_extension_pathContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneralized_extension_pathContext) +} + +func (s *Replace_fields_argContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Replace_fields_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Replace_fields_argContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterReplace_fields_arg(s) + } +} + +func (s *Replace_fields_argContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitReplace_fields_arg(s) + } +} + +func (s *Replace_fields_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitReplace_fields_arg(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Replace_fields_arg() (localctx IReplace_fields_argContext) { + localctx = NewReplace_fields_argContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1104, GoogleSQLParserRULE_replace_fields_arg) + p.SetState(6494) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 802, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6486) + p.expression(0) + } + { + p.SetState(6487) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6488) + p.generalized_path_expression(0) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6490) + p.expression(0) + } + { + p.SetState(6491) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6492) + p.generalized_extension_path(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGeneralized_path_expressionContext is an interface to support dynamic dispatch. +type IGeneralized_path_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Generalized_path_expression() IGeneralized_path_expressionContext + DOT_SYMBOL() antlr.TerminalNode + Generalized_extension_path() IGeneralized_extension_pathContext + LS_BRACKET_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + RS_BRACKET_SYMBOL() antlr.TerminalNode + + // IsGeneralized_path_expressionContext differentiates from other interfaces. + IsGeneralized_path_expressionContext() +} + +type Generalized_path_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGeneralized_path_expressionContext() *Generalized_path_expressionContext { + var p = new(Generalized_path_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_generalized_path_expression + return p +} + +func InitEmptyGeneralized_path_expressionContext(p *Generalized_path_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_generalized_path_expression +} + +func (*Generalized_path_expressionContext) IsGeneralized_path_expressionContext() {} + +func NewGeneralized_path_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generalized_path_expressionContext { + var p = new(Generalized_path_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_generalized_path_expression + + return p +} + +func (s *Generalized_path_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Generalized_path_expressionContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Generalized_path_expressionContext) Generalized_path_expression() IGeneralized_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneralized_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneralized_path_expressionContext) +} + +func (s *Generalized_path_expressionContext) DOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDOT_SYMBOL, 0) +} + +func (s *Generalized_path_expressionContext) Generalized_extension_path() IGeneralized_extension_pathContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneralized_extension_pathContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneralized_extension_pathContext) +} + +func (s *Generalized_path_expressionContext) LS_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLS_BRACKET_SYMBOL, 0) +} + +func (s *Generalized_path_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Generalized_path_expressionContext) RS_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRS_BRACKET_SYMBOL, 0) +} + +func (s *Generalized_path_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Generalized_path_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Generalized_path_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGeneralized_path_expression(s) + } +} + +func (s *Generalized_path_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGeneralized_path_expression(s) + } +} + +func (s *Generalized_path_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGeneralized_path_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Generalized_path_expression() (localctx IGeneralized_path_expressionContext) { + return p.generalized_path_expression(0) +} + +func (p *GoogleSQLParser) generalized_path_expression(_p int) (localctx IGeneralized_path_expressionContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewGeneralized_path_expressionContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IGeneralized_path_expressionContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 1106 + p.EnterRecursionRule(localctx, 1106, GoogleSQLParserRULE_generalized_path_expression, _p) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6497) + p.Identifier() + } + + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(6512) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 804, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + p.SetState(6510) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 803, p.GetParserRuleContext()) { + case 1: + localctx = NewGeneralized_path_expressionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_generalized_path_expression) + p.SetState(6499) + + if !(p.Precpred(p.GetParserRuleContext(), 3)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", "")) + goto errorExit + } + { + p.SetState(6500) + p.Match(GoogleSQLParserDOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6501) + p.generalized_extension_path(0) + } + + case 2: + localctx = NewGeneralized_path_expressionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_generalized_path_expression) + p.SetState(6502) + + if !(p.Precpred(p.GetParserRuleContext(), 2)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) + goto errorExit + } + { + p.SetState(6503) + p.Match(GoogleSQLParserDOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6504) + p.Identifier() + } + + case 3: + localctx = NewGeneralized_path_expressionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_generalized_path_expression) + p.SetState(6505) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(6506) + p.Match(GoogleSQLParserLS_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6507) + p.expression(0) + } + { + p.SetState(6508) + p.Match(GoogleSQLParserRS_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(6514) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 804, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGeneralized_extension_pathContext is an interface to support dynamic dispatch. +type IGeneralized_extension_pathContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + Generalized_extension_path() IGeneralized_extension_pathContext + DOT_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsGeneralized_extension_pathContext differentiates from other interfaces. + IsGeneralized_extension_pathContext() +} + +type Generalized_extension_pathContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGeneralized_extension_pathContext() *Generalized_extension_pathContext { + var p = new(Generalized_extension_pathContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_generalized_extension_path + return p +} + +func InitEmptyGeneralized_extension_pathContext(p *Generalized_extension_pathContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_generalized_extension_path +} + +func (*Generalized_extension_pathContext) IsGeneralized_extension_pathContext() {} + +func NewGeneralized_extension_pathContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generalized_extension_pathContext { + var p = new(Generalized_extension_pathContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_generalized_extension_path + + return p +} + +func (s *Generalized_extension_pathContext) GetParser() antlr.Parser { return s.parser } + +func (s *Generalized_extension_pathContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Generalized_extension_pathContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Generalized_extension_pathContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Generalized_extension_pathContext) Generalized_extension_path() IGeneralized_extension_pathContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneralized_extension_pathContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneralized_extension_pathContext) +} + +func (s *Generalized_extension_pathContext) DOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDOT_SYMBOL, 0) +} + +func (s *Generalized_extension_pathContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Generalized_extension_pathContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Generalized_extension_pathContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Generalized_extension_pathContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterGeneralized_extension_path(s) + } +} + +func (s *Generalized_extension_pathContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitGeneralized_extension_path(s) + } +} + +func (s *Generalized_extension_pathContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitGeneralized_extension_path(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Generalized_extension_path() (localctx IGeneralized_extension_pathContext) { + return p.generalized_extension_path(0) +} + +func (p *GoogleSQLParser) generalized_extension_path(_p int) (localctx IGeneralized_extension_pathContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewGeneralized_extension_pathContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IGeneralized_extension_pathContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 1108 + p.EnterRecursionRule(localctx, 1108, GoogleSQLParserRULE_generalized_extension_path, _p) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6516) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6517) + p.Path_expression() + } + { + p.SetState(6518) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(6531) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 806, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + p.SetState(6529) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 805, p.GetParserRuleContext()) { + case 1: + localctx = NewGeneralized_extension_pathContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_generalized_extension_path) + p.SetState(6520) + + if !(p.Precpred(p.GetParserRuleContext(), 2)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) + goto errorExit + } + { + p.SetState(6521) + p.Match(GoogleSQLParserDOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6522) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6523) + p.Path_expression() + } + { + p.SetState(6524) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + localctx = NewGeneralized_extension_pathContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_generalized_extension_path) + p.SetState(6526) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(6527) + p.Match(GoogleSQLParserDOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6528) + p.Identifier() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(6533) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 806, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWith_expressionContext is an interface to support dynamic dispatch. +type IWith_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + With_expression_variable_prefix() IWith_expression_variable_prefixContext + COMMA_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsWith_expressionContext differentiates from other interfaces. + IsWith_expressionContext() +} + +type With_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWith_expressionContext() *With_expressionContext { + var p = new(With_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_with_expression + return p +} + +func InitEmptyWith_expressionContext(p *With_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_with_expression +} + +func (*With_expressionContext) IsWith_expressionContext() {} + +func NewWith_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_expressionContext { + var p = new(With_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_with_expression + + return p +} + +func (s *With_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *With_expressionContext) WITH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWITH_SYMBOL, 0) +} + +func (s *With_expressionContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *With_expressionContext) With_expression_variable_prefix() IWith_expression_variable_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_expression_variable_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_expression_variable_prefixContext) +} + +func (s *With_expressionContext) COMMA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, 0) +} + +func (s *With_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *With_expressionContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *With_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *With_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *With_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterWith_expression(s) + } +} + +func (s *With_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitWith_expression(s) + } +} + +func (s *With_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitWith_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) With_expression() (localctx IWith_expressionContext) { + localctx = NewWith_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1110, GoogleSQLParserRULE_with_expression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6534) + p.Match(GoogleSQLParserWITH_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6535) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6536) + p.With_expression_variable_prefix() + } + { + p.SetState(6537) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6538) + p.expression(0) + } + { + p.SetState(6539) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWith_expression_variable_prefixContext is an interface to support dynamic dispatch. +type IWith_expression_variable_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllWith_expression_variable() []IWith_expression_variableContext + With_expression_variable(i int) IWith_expression_variableContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsWith_expression_variable_prefixContext differentiates from other interfaces. + IsWith_expression_variable_prefixContext() +} + +type With_expression_variable_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWith_expression_variable_prefixContext() *With_expression_variable_prefixContext { + var p = new(With_expression_variable_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_with_expression_variable_prefix + return p +} + +func InitEmptyWith_expression_variable_prefixContext(p *With_expression_variable_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_with_expression_variable_prefix +} + +func (*With_expression_variable_prefixContext) IsWith_expression_variable_prefixContext() {} + +func NewWith_expression_variable_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_expression_variable_prefixContext { + var p = new(With_expression_variable_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_with_expression_variable_prefix + + return p +} + +func (s *With_expression_variable_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *With_expression_variable_prefixContext) AllWith_expression_variable() []IWith_expression_variableContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWith_expression_variableContext); ok { + len++ + } + } + + tst := make([]IWith_expression_variableContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWith_expression_variableContext); ok { + tst[i] = t.(IWith_expression_variableContext) + i++ + } + } + + return tst +} + +func (s *With_expression_variable_prefixContext) With_expression_variable(i int) IWith_expression_variableContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_expression_variableContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWith_expression_variableContext) +} + +func (s *With_expression_variable_prefixContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *With_expression_variable_prefixContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *With_expression_variable_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *With_expression_variable_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *With_expression_variable_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterWith_expression_variable_prefix(s) + } +} + +func (s *With_expression_variable_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitWith_expression_variable_prefix(s) + } +} + +func (s *With_expression_variable_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitWith_expression_variable_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) With_expression_variable_prefix() (localctx IWith_expression_variable_prefixContext) { + localctx = NewWith_expression_variable_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1112, GoogleSQLParserRULE_with_expression_variable_prefix) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6541) + p.With_expression_variable() + } + p.SetState(6546) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 807, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(6542) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6543) + p.With_expression_variable() + } + + } + p.SetState(6548) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 807, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWith_expression_variableContext is an interface to support dynamic dispatch. +type IWith_expression_variableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + AS_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + + // IsWith_expression_variableContext differentiates from other interfaces. + IsWith_expression_variableContext() +} + +type With_expression_variableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWith_expression_variableContext() *With_expression_variableContext { + var p = new(With_expression_variableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_with_expression_variable + return p +} + +func InitEmptyWith_expression_variableContext(p *With_expression_variableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_with_expression_variable +} + +func (*With_expression_variableContext) IsWith_expression_variableContext() {} + +func NewWith_expression_variableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_expression_variableContext { + var p = new(With_expression_variableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_with_expression_variable + + return p +} + +func (s *With_expression_variableContext) GetParser() antlr.Parser { return s.parser } + +func (s *With_expression_variableContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *With_expression_variableContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *With_expression_variableContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *With_expression_variableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *With_expression_variableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *With_expression_variableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterWith_expression_variable(s) + } +} + +func (s *With_expression_variableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitWith_expression_variable(s) + } +} + +func (s *With_expression_variableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitWith_expression_variable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) With_expression_variable() (localctx IWith_expression_variableContext) { + localctx = NewWith_expression_variableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1114, GoogleSQLParserRULE_with_expression_variable) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6549) + p.Identifier() + } + { + p.SetState(6550) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6551) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExtract_expressionContext is an interface to support dynamic dispatch. +type IExtract_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Extract_expression_base() IExtract_expression_baseContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + AT_SYMBOL() antlr.TerminalNode + TIME_SYMBOL() antlr.TerminalNode + ZONE_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + + // IsExtract_expressionContext differentiates from other interfaces. + IsExtract_expressionContext() +} + +type Extract_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExtract_expressionContext() *Extract_expressionContext { + var p = new(Extract_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_extract_expression + return p +} + +func InitEmptyExtract_expressionContext(p *Extract_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_extract_expression +} + +func (*Extract_expressionContext) IsExtract_expressionContext() {} + +func NewExtract_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Extract_expressionContext { + var p = new(Extract_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_extract_expression + + return p +} + +func (s *Extract_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Extract_expressionContext) Extract_expression_base() IExtract_expression_baseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtract_expression_baseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExtract_expression_baseContext) +} + +func (s *Extract_expressionContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Extract_expressionContext) AT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAT_SYMBOL, 0) +} + +func (s *Extract_expressionContext) TIME_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTIME_SYMBOL, 0) +} + +func (s *Extract_expressionContext) ZONE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserZONE_SYMBOL, 0) +} + +func (s *Extract_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Extract_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Extract_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Extract_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterExtract_expression(s) + } +} + +func (s *Extract_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitExtract_expression(s) + } +} + +func (s *Extract_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitExtract_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Extract_expression() (localctx IExtract_expressionContext) { + localctx = NewExtract_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1116, GoogleSQLParserRULE_extract_expression) + p.SetState(6563) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 808, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6553) + p.Extract_expression_base() + } + { + p.SetState(6554) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6556) + p.Extract_expression_base() + } + { + p.SetState(6557) + p.Match(GoogleSQLParserAT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6558) + p.Match(GoogleSQLParserTIME_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6559) + p.Match(GoogleSQLParserZONE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6560) + p.expression(0) + } + { + p.SetState(6561) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExtract_expression_baseContext is an interface to support dynamic dispatch. +type IExtract_expression_baseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXTRACT_SYMBOL() antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + FROM_SYMBOL() antlr.TerminalNode + + // IsExtract_expression_baseContext differentiates from other interfaces. + IsExtract_expression_baseContext() +} + +type Extract_expression_baseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExtract_expression_baseContext() *Extract_expression_baseContext { + var p = new(Extract_expression_baseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_extract_expression_base + return p +} + +func InitEmptyExtract_expression_baseContext(p *Extract_expression_baseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_extract_expression_base +} + +func (*Extract_expression_baseContext) IsExtract_expression_baseContext() {} + +func NewExtract_expression_baseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Extract_expression_baseContext { + var p = new(Extract_expression_baseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_extract_expression_base + + return p +} + +func (s *Extract_expression_baseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Extract_expression_baseContext) EXTRACT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXTRACT_SYMBOL, 0) +} + +func (s *Extract_expression_baseContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Extract_expression_baseContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Extract_expression_baseContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Extract_expression_baseContext) FROM_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFROM_SYMBOL, 0) +} + +func (s *Extract_expression_baseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Extract_expression_baseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Extract_expression_baseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterExtract_expression_base(s) + } +} + +func (s *Extract_expression_baseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitExtract_expression_base(s) + } +} + +func (s *Extract_expression_baseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitExtract_expression_base(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Extract_expression_base() (localctx IExtract_expression_baseContext) { + localctx = NewExtract_expression_baseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1118, GoogleSQLParserRULE_extract_expression_base) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6565) + p.Match(GoogleSQLParserEXTRACT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6566) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6567) + p.expression(0) + } + { + p.SetState(6568) + p.Match(GoogleSQLParserFROM_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6569) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_formatContext is an interface to support dynamic dispatch. +type IOpt_formatContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FORMAT_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + Opt_at_time_zone() IOpt_at_time_zoneContext + + // IsOpt_formatContext differentiates from other interfaces. + IsOpt_formatContext() +} + +type Opt_formatContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_formatContext() *Opt_formatContext { + var p = new(Opt_formatContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_format + return p +} + +func InitEmptyOpt_formatContext(p *Opt_formatContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_format +} + +func (*Opt_formatContext) IsOpt_formatContext() {} + +func NewOpt_formatContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_formatContext { + var p = new(Opt_formatContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_format + + return p +} + +func (s *Opt_formatContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_formatContext) FORMAT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFORMAT_SYMBOL, 0) +} + +func (s *Opt_formatContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Opt_formatContext) Opt_at_time_zone() IOpt_at_time_zoneContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_at_time_zoneContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_at_time_zoneContext) +} + +func (s *Opt_formatContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_formatContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_formatContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_format(s) + } +} + +func (s *Opt_formatContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_format(s) + } +} + +func (s *Opt_formatContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_format(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_format() (localctx IOpt_formatContext) { + localctx = NewOpt_formatContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1120, GoogleSQLParserRULE_opt_format) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6571) + p.Match(GoogleSQLParserFORMAT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6572) + p.expression(0) + } + p.SetState(6574) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserAT_SYMBOL { + { + p.SetState(6573) + p.Opt_at_time_zone() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_at_time_zoneContext is an interface to support dynamic dispatch. +type IOpt_at_time_zoneContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AT_SYMBOL() antlr.TerminalNode + TIME_SYMBOL() antlr.TerminalNode + ZONE_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + + // IsOpt_at_time_zoneContext differentiates from other interfaces. + IsOpt_at_time_zoneContext() +} + +type Opt_at_time_zoneContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_at_time_zoneContext() *Opt_at_time_zoneContext { + var p = new(Opt_at_time_zoneContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_at_time_zone + return p +} + +func InitEmptyOpt_at_time_zoneContext(p *Opt_at_time_zoneContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_at_time_zone +} + +func (*Opt_at_time_zoneContext) IsOpt_at_time_zoneContext() {} + +func NewOpt_at_time_zoneContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_at_time_zoneContext { + var p = new(Opt_at_time_zoneContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_at_time_zone + + return p +} + +func (s *Opt_at_time_zoneContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_at_time_zoneContext) AT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAT_SYMBOL, 0) +} + +func (s *Opt_at_time_zoneContext) TIME_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTIME_SYMBOL, 0) +} + +func (s *Opt_at_time_zoneContext) ZONE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserZONE_SYMBOL, 0) +} + +func (s *Opt_at_time_zoneContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Opt_at_time_zoneContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_at_time_zoneContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_at_time_zoneContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_at_time_zone(s) + } +} + +func (s *Opt_at_time_zoneContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_at_time_zone(s) + } +} + +func (s *Opt_at_time_zoneContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_at_time_zone(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_at_time_zone() (localctx IOpt_at_time_zoneContext) { + localctx = NewOpt_at_time_zoneContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1122, GoogleSQLParserRULE_opt_at_time_zone) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6576) + p.Match(GoogleSQLParserAT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6577) + p.Match(GoogleSQLParserTIME_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6578) + p.Match(GoogleSQLParserZONE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6579) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICast_expressionContext is an interface to support dynamic dispatch. +type ICast_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllCAST_SYMBOL() []antlr.TerminalNode + CAST_SYMBOL(i int) antlr.TerminalNode + LR_BRACKET_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + AS_SYMBOL() antlr.TerminalNode + Type_() ITypeContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + Opt_format() IOpt_formatContext + AllSAFE_CAST_SYMBOL() []antlr.TerminalNode + SAFE_CAST_SYMBOL(i int) antlr.TerminalNode + + // IsCast_expressionContext differentiates from other interfaces. + IsCast_expressionContext() +} + +type Cast_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCast_expressionContext() *Cast_expressionContext { + var p = new(Cast_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_cast_expression + return p +} + +func InitEmptyCast_expressionContext(p *Cast_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_cast_expression +} + +func (*Cast_expressionContext) IsCast_expressionContext() {} + +func NewCast_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cast_expressionContext { + var p = new(Cast_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_cast_expression + + return p +} + +func (s *Cast_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cast_expressionContext) AllCAST_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCAST_SYMBOL) +} + +func (s *Cast_expressionContext) CAST_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCAST_SYMBOL, i) +} + +func (s *Cast_expressionContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Cast_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Cast_expressionContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *Cast_expressionContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *Cast_expressionContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Cast_expressionContext) Opt_format() IOpt_formatContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_formatContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_formatContext) +} + +func (s *Cast_expressionContext) AllSAFE_CAST_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserSAFE_CAST_SYMBOL) +} + +func (s *Cast_expressionContext) SAFE_CAST_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSAFE_CAST_SYMBOL, i) +} + +func (s *Cast_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cast_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cast_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCast_expression(s) + } +} + +func (s *Cast_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCast_expression(s) + } +} + +func (s *Cast_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCast_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Cast_expression() (localctx ICast_expressionContext) { + localctx = NewCast_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1124, GoogleSQLParserRULE_cast_expression) + var _la int + + p.SetState(6609) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 812, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6581) + p.Match(GoogleSQLParserCAST_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6582) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6583) + p.expression(0) + } + { + p.SetState(6584) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6585) + p.Type_() + } + p.SetState(6587) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserFORMAT_SYMBOL { + { + p.SetState(6586) + p.Opt_format() + } + + } + { + p.SetState(6589) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6591) + p.Match(GoogleSQLParserCAST_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6592) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6593) + p.Match(GoogleSQLParserCAST_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.NotifyErrorListeners("The argument to CAST is an expression, not a query; to use a query as an expression, the query must be wrapped with additional parentheses to make it a scalar subquery expression", nil, nil) + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6595) + p.Match(GoogleSQLParserSAFE_CAST_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6596) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6597) + p.expression(0) + } + { + p.SetState(6598) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6599) + p.Type_() + } + p.SetState(6601) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserFORMAT_SYMBOL { + { + p.SetState(6600) + p.Opt_format() + } + + } + { + p.SetState(6603) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6605) + p.Match(GoogleSQLParserSAFE_CAST_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6606) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6607) + p.Match(GoogleSQLParserSAFE_CAST_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.NotifyErrorListeners("The argument to CAST is an expression, not a query; to use a query as an expression, the query must be wrapped with additional parentheses to make it a scalar subquery expression", nil, nil) + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICase_expressionContext is an interface to support dynamic dispatch. +type ICase_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Case_expression_prefix() ICase_expression_prefixContext + END_SYMBOL() antlr.TerminalNode + ELSE_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + + // IsCase_expressionContext differentiates from other interfaces. + IsCase_expressionContext() +} + +type Case_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCase_expressionContext() *Case_expressionContext { + var p = new(Case_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_case_expression + return p +} + +func InitEmptyCase_expressionContext(p *Case_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_case_expression +} + +func (*Case_expressionContext) IsCase_expressionContext() {} + +func NewCase_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_expressionContext { + var p = new(Case_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_case_expression + + return p +} + +func (s *Case_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Case_expressionContext) Case_expression_prefix() ICase_expression_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_expression_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICase_expression_prefixContext) +} + +func (s *Case_expressionContext) END_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEND_SYMBOL, 0) +} + +func (s *Case_expressionContext) ELSE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserELSE_SYMBOL, 0) +} + +func (s *Case_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Case_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Case_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Case_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCase_expression(s) + } +} + +func (s *Case_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCase_expression(s) + } +} + +func (s *Case_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCase_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Case_expression() (localctx ICase_expressionContext) { + localctx = NewCase_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1126, GoogleSQLParserRULE_case_expression) + p.SetState(6619) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 813, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6611) + p.Case_expression_prefix() + } + { + p.SetState(6612) + p.Match(GoogleSQLParserEND_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6614) + p.Case_expression_prefix() + } + { + p.SetState(6615) + p.Match(GoogleSQLParserELSE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6616) + p.expression(0) + } + { + p.SetState(6617) + p.Match(GoogleSQLParserEND_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICase_expression_prefixContext is an interface to support dynamic dispatch. +type ICase_expression_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Case_no_value_expression_prefix() ICase_no_value_expression_prefixContext + Case_value_expression_prefix() ICase_value_expression_prefixContext + + // IsCase_expression_prefixContext differentiates from other interfaces. + IsCase_expression_prefixContext() +} + +type Case_expression_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCase_expression_prefixContext() *Case_expression_prefixContext { + var p = new(Case_expression_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_case_expression_prefix + return p +} + +func InitEmptyCase_expression_prefixContext(p *Case_expression_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_case_expression_prefix +} + +func (*Case_expression_prefixContext) IsCase_expression_prefixContext() {} + +func NewCase_expression_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_expression_prefixContext { + var p = new(Case_expression_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_case_expression_prefix + + return p +} + +func (s *Case_expression_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Case_expression_prefixContext) Case_no_value_expression_prefix() ICase_no_value_expression_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_no_value_expression_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICase_no_value_expression_prefixContext) +} + +func (s *Case_expression_prefixContext) Case_value_expression_prefix() ICase_value_expression_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_value_expression_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICase_value_expression_prefixContext) +} + +func (s *Case_expression_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Case_expression_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Case_expression_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCase_expression_prefix(s) + } +} + +func (s *Case_expression_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCase_expression_prefix(s) + } +} + +func (s *Case_expression_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCase_expression_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Case_expression_prefix() (localctx ICase_expression_prefixContext) { + localctx = NewCase_expression_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1128, GoogleSQLParserRULE_case_expression_prefix) + p.SetState(6623) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 814, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6621) + p.Case_no_value_expression_prefix() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6622) + p.Case_value_expression_prefix() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICase_value_expression_prefixContext is an interface to support dynamic dispatch. +type ICase_value_expression_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CASE_SYMBOL() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllWHEN_SYMBOL() []antlr.TerminalNode + WHEN_SYMBOL(i int) antlr.TerminalNode + AllTHEN_SYMBOL() []antlr.TerminalNode + THEN_SYMBOL(i int) antlr.TerminalNode + + // IsCase_value_expression_prefixContext differentiates from other interfaces. + IsCase_value_expression_prefixContext() +} + +type Case_value_expression_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCase_value_expression_prefixContext() *Case_value_expression_prefixContext { + var p = new(Case_value_expression_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_case_value_expression_prefix + return p +} + +func InitEmptyCase_value_expression_prefixContext(p *Case_value_expression_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_case_value_expression_prefix +} + +func (*Case_value_expression_prefixContext) IsCase_value_expression_prefixContext() {} + +func NewCase_value_expression_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_value_expression_prefixContext { + var p = new(Case_value_expression_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_case_value_expression_prefix + + return p +} + +func (s *Case_value_expression_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Case_value_expression_prefixContext) CASE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCASE_SYMBOL, 0) +} + +func (s *Case_value_expression_prefixContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Case_value_expression_prefixContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Case_value_expression_prefixContext) AllWHEN_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserWHEN_SYMBOL) +} + +func (s *Case_value_expression_prefixContext) WHEN_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWHEN_SYMBOL, i) +} + +func (s *Case_value_expression_prefixContext) AllTHEN_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserTHEN_SYMBOL) +} + +func (s *Case_value_expression_prefixContext) THEN_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTHEN_SYMBOL, i) +} + +func (s *Case_value_expression_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Case_value_expression_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Case_value_expression_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCase_value_expression_prefix(s) + } +} + +func (s *Case_value_expression_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCase_value_expression_prefix(s) + } +} + +func (s *Case_value_expression_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCase_value_expression_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Case_value_expression_prefix() (localctx ICase_value_expression_prefixContext) { + localctx = NewCase_value_expression_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1130, GoogleSQLParserRULE_case_value_expression_prefix) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6625) + p.Match(GoogleSQLParserCASE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6626) + p.expression(0) + } + p.SetState(6632) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == GoogleSQLParserWHEN_SYMBOL { + { + p.SetState(6627) + p.Match(GoogleSQLParserWHEN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6628) + p.expression(0) + } + { + p.SetState(6629) + p.Match(GoogleSQLParserTHEN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6630) + p.expression(0) + } + + p.SetState(6634) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICase_no_value_expression_prefixContext is an interface to support dynamic dispatch. +type ICase_no_value_expression_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CASE_SYMBOL() antlr.TerminalNode + AllWHEN_SYMBOL() []antlr.TerminalNode + WHEN_SYMBOL(i int) antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllTHEN_SYMBOL() []antlr.TerminalNode + THEN_SYMBOL(i int) antlr.TerminalNode + + // IsCase_no_value_expression_prefixContext differentiates from other interfaces. + IsCase_no_value_expression_prefixContext() +} + +type Case_no_value_expression_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCase_no_value_expression_prefixContext() *Case_no_value_expression_prefixContext { + var p = new(Case_no_value_expression_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_case_no_value_expression_prefix + return p +} + +func InitEmptyCase_no_value_expression_prefixContext(p *Case_no_value_expression_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_case_no_value_expression_prefix +} + +func (*Case_no_value_expression_prefixContext) IsCase_no_value_expression_prefixContext() {} + +func NewCase_no_value_expression_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_no_value_expression_prefixContext { + var p = new(Case_no_value_expression_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_case_no_value_expression_prefix + + return p +} + +func (s *Case_no_value_expression_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Case_no_value_expression_prefixContext) CASE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCASE_SYMBOL, 0) +} + +func (s *Case_no_value_expression_prefixContext) AllWHEN_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserWHEN_SYMBOL) +} + +func (s *Case_no_value_expression_prefixContext) WHEN_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWHEN_SYMBOL, i) +} + +func (s *Case_no_value_expression_prefixContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Case_no_value_expression_prefixContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Case_no_value_expression_prefixContext) AllTHEN_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserTHEN_SYMBOL) +} + +func (s *Case_no_value_expression_prefixContext) THEN_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTHEN_SYMBOL, i) +} + +func (s *Case_no_value_expression_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Case_no_value_expression_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Case_no_value_expression_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCase_no_value_expression_prefix(s) + } +} + +func (s *Case_no_value_expression_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCase_no_value_expression_prefix(s) + } +} + +func (s *Case_no_value_expression_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCase_no_value_expression_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Case_no_value_expression_prefix() (localctx ICase_no_value_expression_prefixContext) { + localctx = NewCase_no_value_expression_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1132, GoogleSQLParserRULE_case_no_value_expression_prefix) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6636) + p.Match(GoogleSQLParserCASE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6642) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == GoogleSQLParserWHEN_SYMBOL { + { + p.SetState(6637) + p.Match(GoogleSQLParserWHEN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6638) + p.expression(0) + } + { + p.SetState(6639) + p.Match(GoogleSQLParserTHEN_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6640) + p.expression(0) + } + + p.SetState(6644) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStruct_braced_constructorContext is an interface to support dynamic dispatch. +type IStruct_braced_constructorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetStype returns the stype rule contexts. + GetStype() IStruct_typeContext + + // GetCtor returns the ctor rule contexts. + GetCtor() IBraced_constructorContext + + // SetStype sets the stype rule contexts. + SetStype(IStruct_typeContext) + + // SetCtor sets the ctor rule contexts. + SetCtor(IBraced_constructorContext) + + // Getter signatures + Struct_type() IStruct_typeContext + Braced_constructor() IBraced_constructorContext + STRUCT_SYMBOL() antlr.TerminalNode + + // IsStruct_braced_constructorContext differentiates from other interfaces. + IsStruct_braced_constructorContext() +} + +type Struct_braced_constructorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + stype IStruct_typeContext + ctor IBraced_constructorContext +} + +func NewEmptyStruct_braced_constructorContext() *Struct_braced_constructorContext { + var p = new(Struct_braced_constructorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_struct_braced_constructor + return p +} + +func InitEmptyStruct_braced_constructorContext(p *Struct_braced_constructorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_struct_braced_constructor +} + +func (*Struct_braced_constructorContext) IsStruct_braced_constructorContext() {} + +func NewStruct_braced_constructorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Struct_braced_constructorContext { + var p = new(Struct_braced_constructorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_struct_braced_constructor + + return p +} + +func (s *Struct_braced_constructorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Struct_braced_constructorContext) GetStype() IStruct_typeContext { return s.stype } + +func (s *Struct_braced_constructorContext) GetCtor() IBraced_constructorContext { return s.ctor } + +func (s *Struct_braced_constructorContext) SetStype(v IStruct_typeContext) { s.stype = v } + +func (s *Struct_braced_constructorContext) SetCtor(v IBraced_constructorContext) { s.ctor = v } + +func (s *Struct_braced_constructorContext) Struct_type() IStruct_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStruct_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStruct_typeContext) +} + +func (s *Struct_braced_constructorContext) Braced_constructor() IBraced_constructorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBraced_constructorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBraced_constructorContext) +} + +func (s *Struct_braced_constructorContext) STRUCT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTRUCT_SYMBOL, 0) +} + +func (s *Struct_braced_constructorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Struct_braced_constructorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Struct_braced_constructorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterStruct_braced_constructor(s) + } +} + +func (s *Struct_braced_constructorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitStruct_braced_constructor(s) + } +} + +func (s *Struct_braced_constructorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitStruct_braced_constructor(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Struct_braced_constructor() (localctx IStruct_braced_constructorContext) { + localctx = NewStruct_braced_constructorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1134, GoogleSQLParserRULE_struct_braced_constructor) + p.SetState(6651) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 817, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6646) + + var _x = p.Struct_type() + + localctx.(*Struct_braced_constructorContext).stype = _x + } + { + p.SetState(6647) + + var _x = p.Braced_constructor() + + localctx.(*Struct_braced_constructorContext).ctor = _x + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6649) + p.Match(GoogleSQLParserSTRUCT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6650) + + var _x = p.Braced_constructor() + + localctx.(*Struct_braced_constructorContext).ctor = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBraced_new_constructorContext is an interface to support dynamic dispatch. +type IBraced_new_constructorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NEW_SYMBOL() antlr.TerminalNode + Type_name() IType_nameContext + New_constructor() INew_constructorContext + + // IsBraced_new_constructorContext differentiates from other interfaces. + IsBraced_new_constructorContext() +} + +type Braced_new_constructorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBraced_new_constructorContext() *Braced_new_constructorContext { + var p = new(Braced_new_constructorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_braced_new_constructor + return p +} + +func InitEmptyBraced_new_constructorContext(p *Braced_new_constructorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_braced_new_constructor +} + +func (*Braced_new_constructorContext) IsBraced_new_constructorContext() {} + +func NewBraced_new_constructorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Braced_new_constructorContext { + var p = new(Braced_new_constructorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_braced_new_constructor + + return p +} + +func (s *Braced_new_constructorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Braced_new_constructorContext) NEW_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNEW_SYMBOL, 0) +} + +func (s *Braced_new_constructorContext) Type_name() IType_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_nameContext) +} + +func (s *Braced_new_constructorContext) New_constructor() INew_constructorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INew_constructorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INew_constructorContext) +} + +func (s *Braced_new_constructorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Braced_new_constructorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Braced_new_constructorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterBraced_new_constructor(s) + } +} + +func (s *Braced_new_constructorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitBraced_new_constructor(s) + } +} + +func (s *Braced_new_constructorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitBraced_new_constructor(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Braced_new_constructor() (localctx IBraced_new_constructorContext) { + localctx = NewBraced_new_constructorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1136, GoogleSQLParserRULE_braced_new_constructor) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6653) + p.Match(GoogleSQLParserNEW_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6654) + p.Type_name() + } + { + p.SetState(6655) + p.New_constructor() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBraced_constructorContext is an interface to support dynamic dispatch. +type IBraced_constructorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Braced_constructor_start() IBraced_constructor_startContext + AllRC_BRACKET_SYMBOL() []antlr.TerminalNode + RC_BRACKET_SYMBOL(i int) antlr.TerminalNode + Braced_constructor_prefix() IBraced_constructor_prefixContext + COMMA_SYMBOL() antlr.TerminalNode + + // IsBraced_constructorContext differentiates from other interfaces. + IsBraced_constructorContext() +} + +type Braced_constructorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBraced_constructorContext() *Braced_constructorContext { + var p = new(Braced_constructorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_braced_constructor + return p +} + +func InitEmptyBraced_constructorContext(p *Braced_constructorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_braced_constructor +} + +func (*Braced_constructorContext) IsBraced_constructorContext() {} + +func NewBraced_constructorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Braced_constructorContext { + var p = new(Braced_constructorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_braced_constructor + + return p +} + +func (s *Braced_constructorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Braced_constructorContext) Braced_constructor_start() IBraced_constructor_startContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBraced_constructor_startContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBraced_constructor_startContext) +} + +func (s *Braced_constructorContext) AllRC_BRACKET_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserRC_BRACKET_SYMBOL) +} + +func (s *Braced_constructorContext) RC_BRACKET_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRC_BRACKET_SYMBOL, i) +} + +func (s *Braced_constructorContext) Braced_constructor_prefix() IBraced_constructor_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBraced_constructor_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBraced_constructor_prefixContext) +} + +func (s *Braced_constructorContext) COMMA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, 0) +} + +func (s *Braced_constructorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Braced_constructorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Braced_constructorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterBraced_constructor(s) + } +} + +func (s *Braced_constructorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitBraced_constructor(s) + } +} + +func (s *Braced_constructorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitBraced_constructor(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Braced_constructor() (localctx IBraced_constructorContext) { + localctx = NewBraced_constructorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1138, GoogleSQLParserRULE_braced_constructor) + p.SetState(6665) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 818, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6657) + p.Braced_constructor_start() + } + { + p.SetState(6658) + p.Match(GoogleSQLParserRC_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6660) + p.braced_constructor_prefix(0) + } + { + p.SetState(6661) + p.Match(GoogleSQLParserRC_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6662) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6663) + p.Match(GoogleSQLParserRC_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBraced_constructor_startContext is an interface to support dynamic dispatch. +type IBraced_constructor_startContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RC_BRACKET_SYMBOL() antlr.TerminalNode + + // IsBraced_constructor_startContext differentiates from other interfaces. + IsBraced_constructor_startContext() +} + +type Braced_constructor_startContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBraced_constructor_startContext() *Braced_constructor_startContext { + var p = new(Braced_constructor_startContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_braced_constructor_start + return p +} + +func InitEmptyBraced_constructor_startContext(p *Braced_constructor_startContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_braced_constructor_start +} + +func (*Braced_constructor_startContext) IsBraced_constructor_startContext() {} + +func NewBraced_constructor_startContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Braced_constructor_startContext { + var p = new(Braced_constructor_startContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_braced_constructor_start + + return p +} + +func (s *Braced_constructor_startContext) GetParser() antlr.Parser { return s.parser } + +func (s *Braced_constructor_startContext) RC_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRC_BRACKET_SYMBOL, 0) +} + +func (s *Braced_constructor_startContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Braced_constructor_startContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Braced_constructor_startContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterBraced_constructor_start(s) + } +} + +func (s *Braced_constructor_startContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitBraced_constructor_start(s) + } +} + +func (s *Braced_constructor_startContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitBraced_constructor_start(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Braced_constructor_start() (localctx IBraced_constructor_startContext) { + localctx = NewBraced_constructor_startContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1140, GoogleSQLParserRULE_braced_constructor_start) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6667) + p.Match(GoogleSQLParserRC_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBraced_constructor_prefixContext is an interface to support dynamic dispatch. +type IBraced_constructor_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Braced_constructor_start() IBraced_constructor_startContext + Braced_constructor_field() IBraced_constructor_fieldContext + Braced_constructor_extension() IBraced_constructor_extensionContext + Braced_constructor_prefix() IBraced_constructor_prefixContext + COMMA_SYMBOL() antlr.TerminalNode + + // IsBraced_constructor_prefixContext differentiates from other interfaces. + IsBraced_constructor_prefixContext() +} + +type Braced_constructor_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBraced_constructor_prefixContext() *Braced_constructor_prefixContext { + var p = new(Braced_constructor_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_braced_constructor_prefix + return p +} + +func InitEmptyBraced_constructor_prefixContext(p *Braced_constructor_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_braced_constructor_prefix +} + +func (*Braced_constructor_prefixContext) IsBraced_constructor_prefixContext() {} + +func NewBraced_constructor_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Braced_constructor_prefixContext { + var p = new(Braced_constructor_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_braced_constructor_prefix + + return p +} + +func (s *Braced_constructor_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Braced_constructor_prefixContext) Braced_constructor_start() IBraced_constructor_startContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBraced_constructor_startContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBraced_constructor_startContext) +} + +func (s *Braced_constructor_prefixContext) Braced_constructor_field() IBraced_constructor_fieldContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBraced_constructor_fieldContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBraced_constructor_fieldContext) +} + +func (s *Braced_constructor_prefixContext) Braced_constructor_extension() IBraced_constructor_extensionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBraced_constructor_extensionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBraced_constructor_extensionContext) +} + +func (s *Braced_constructor_prefixContext) Braced_constructor_prefix() IBraced_constructor_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBraced_constructor_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBraced_constructor_prefixContext) +} + +func (s *Braced_constructor_prefixContext) COMMA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, 0) +} + +func (s *Braced_constructor_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Braced_constructor_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Braced_constructor_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterBraced_constructor_prefix(s) + } +} + +func (s *Braced_constructor_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitBraced_constructor_prefix(s) + } +} + +func (s *Braced_constructor_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitBraced_constructor_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Braced_constructor_prefix() (localctx IBraced_constructor_prefixContext) { + return p.braced_constructor_prefix(0) +} + +func (p *GoogleSQLParser) braced_constructor_prefix(_p int) (localctx IBraced_constructor_prefixContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewBraced_constructor_prefixContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IBraced_constructor_prefixContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 1142 + p.EnterRecursionRule(localctx, 1142, GoogleSQLParserRULE_braced_constructor_prefix, _p) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(6676) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 819, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6670) + p.Braced_constructor_start() + } + { + p.SetState(6671) + p.Braced_constructor_field() + } + + case 2: + { + p.SetState(6673) + p.Braced_constructor_start() + } + { + p.SetState(6674) + p.Braced_constructor_extension() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(6688) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 821, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + p.SetState(6686) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 820, p.GetParserRuleContext()) { + case 1: + localctx = NewBraced_constructor_prefixContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_braced_constructor_prefix) + p.SetState(6678) + + if !(p.Precpred(p.GetParserRuleContext(), 3)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", "")) + goto errorExit + } + { + p.SetState(6679) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6680) + p.Braced_constructor_field() + } + + case 2: + localctx = NewBraced_constructor_prefixContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_braced_constructor_prefix) + p.SetState(6681) + + if !(p.Precpred(p.GetParserRuleContext(), 2)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) + goto errorExit + } + { + p.SetState(6682) + p.Braced_constructor_field() + } + + case 3: + localctx = NewBraced_constructor_prefixContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_braced_constructor_prefix) + p.SetState(6683) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(6684) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6685) + p.Braced_constructor_extension() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(6690) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 821, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBraced_constructor_fieldContext is an interface to support dynamic dispatch. +type IBraced_constructor_fieldContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Braced_constructor_lhs() IBraced_constructor_lhsContext + Braced_constructor_field_value() IBraced_constructor_field_valueContext + + // IsBraced_constructor_fieldContext differentiates from other interfaces. + IsBraced_constructor_fieldContext() +} + +type Braced_constructor_fieldContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBraced_constructor_fieldContext() *Braced_constructor_fieldContext { + var p = new(Braced_constructor_fieldContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_braced_constructor_field + return p +} + +func InitEmptyBraced_constructor_fieldContext(p *Braced_constructor_fieldContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_braced_constructor_field +} + +func (*Braced_constructor_fieldContext) IsBraced_constructor_fieldContext() {} + +func NewBraced_constructor_fieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Braced_constructor_fieldContext { + var p = new(Braced_constructor_fieldContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_braced_constructor_field + + return p +} + +func (s *Braced_constructor_fieldContext) GetParser() antlr.Parser { return s.parser } + +func (s *Braced_constructor_fieldContext) Braced_constructor_lhs() IBraced_constructor_lhsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBraced_constructor_lhsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBraced_constructor_lhsContext) +} + +func (s *Braced_constructor_fieldContext) Braced_constructor_field_value() IBraced_constructor_field_valueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBraced_constructor_field_valueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBraced_constructor_field_valueContext) +} + +func (s *Braced_constructor_fieldContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Braced_constructor_fieldContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Braced_constructor_fieldContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterBraced_constructor_field(s) + } +} + +func (s *Braced_constructor_fieldContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitBraced_constructor_field(s) + } +} + +func (s *Braced_constructor_fieldContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitBraced_constructor_field(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Braced_constructor_field() (localctx IBraced_constructor_fieldContext) { + localctx = NewBraced_constructor_fieldContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1144, GoogleSQLParserRULE_braced_constructor_field) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6691) + p.Braced_constructor_lhs() + } + { + p.SetState(6692) + p.Braced_constructor_field_value() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBraced_constructor_lhsContext is an interface to support dynamic dispatch. +type IBraced_constructor_lhsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Generalized_path_expression() IGeneralized_path_expressionContext + + // IsBraced_constructor_lhsContext differentiates from other interfaces. + IsBraced_constructor_lhsContext() +} + +type Braced_constructor_lhsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBraced_constructor_lhsContext() *Braced_constructor_lhsContext { + var p = new(Braced_constructor_lhsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_braced_constructor_lhs + return p +} + +func InitEmptyBraced_constructor_lhsContext(p *Braced_constructor_lhsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_braced_constructor_lhs +} + +func (*Braced_constructor_lhsContext) IsBraced_constructor_lhsContext() {} + +func NewBraced_constructor_lhsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Braced_constructor_lhsContext { + var p = new(Braced_constructor_lhsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_braced_constructor_lhs + + return p +} + +func (s *Braced_constructor_lhsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Braced_constructor_lhsContext) Generalized_path_expression() IGeneralized_path_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneralized_path_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneralized_path_expressionContext) +} + +func (s *Braced_constructor_lhsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Braced_constructor_lhsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Braced_constructor_lhsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterBraced_constructor_lhs(s) + } +} + +func (s *Braced_constructor_lhsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitBraced_constructor_lhs(s) + } +} + +func (s *Braced_constructor_lhsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitBraced_constructor_lhs(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Braced_constructor_lhs() (localctx IBraced_constructor_lhsContext) { + localctx = NewBraced_constructor_lhsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1146, GoogleSQLParserRULE_braced_constructor_lhs) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6694) + p.generalized_path_expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBraced_constructor_field_valueContext is an interface to support dynamic dispatch. +type IBraced_constructor_field_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COLON_SYMBOL() antlr.TerminalNode + Expression() IExpressionContext + Braced_constructor() IBraced_constructorContext + + // IsBraced_constructor_field_valueContext differentiates from other interfaces. + IsBraced_constructor_field_valueContext() +} + +type Braced_constructor_field_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBraced_constructor_field_valueContext() *Braced_constructor_field_valueContext { + var p = new(Braced_constructor_field_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_braced_constructor_field_value + return p +} + +func InitEmptyBraced_constructor_field_valueContext(p *Braced_constructor_field_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_braced_constructor_field_value +} + +func (*Braced_constructor_field_valueContext) IsBraced_constructor_field_valueContext() {} + +func NewBraced_constructor_field_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Braced_constructor_field_valueContext { + var p = new(Braced_constructor_field_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_braced_constructor_field_value + + return p +} + +func (s *Braced_constructor_field_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Braced_constructor_field_valueContext) COLON_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOLON_SYMBOL, 0) +} + +func (s *Braced_constructor_field_valueContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Braced_constructor_field_valueContext) Braced_constructor() IBraced_constructorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBraced_constructorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBraced_constructorContext) +} + +func (s *Braced_constructor_field_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Braced_constructor_field_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Braced_constructor_field_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterBraced_constructor_field_value(s) + } +} + +func (s *Braced_constructor_field_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitBraced_constructor_field_value(s) + } +} + +func (s *Braced_constructor_field_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitBraced_constructor_field_value(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Braced_constructor_field_value() (localctx IBraced_constructor_field_valueContext) { + localctx = NewBraced_constructor_field_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1148, GoogleSQLParserRULE_braced_constructor_field_value) + p.SetState(6699) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserCOLON_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6696) + p.Match(GoogleSQLParserCOLON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6697) + p.expression(0) + } + + case GoogleSQLParserRC_BRACKET_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6698) + p.Braced_constructor() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBraced_constructor_extensionContext is an interface to support dynamic dispatch. +type IBraced_constructor_extensionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsBraced_constructor_extensionContext differentiates from other interfaces. + IsBraced_constructor_extensionContext() +} + +type Braced_constructor_extensionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBraced_constructor_extensionContext() *Braced_constructor_extensionContext { + var p = new(Braced_constructor_extensionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_braced_constructor_extension + return p +} + +func InitEmptyBraced_constructor_extensionContext(p *Braced_constructor_extensionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_braced_constructor_extension +} + +func (*Braced_constructor_extensionContext) IsBraced_constructor_extensionContext() {} + +func NewBraced_constructor_extensionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Braced_constructor_extensionContext { + var p = new(Braced_constructor_extensionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_braced_constructor_extension + + return p +} + +func (s *Braced_constructor_extensionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Braced_constructor_extensionContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Braced_constructor_extensionContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Braced_constructor_extensionContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Braced_constructor_extensionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Braced_constructor_extensionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Braced_constructor_extensionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterBraced_constructor_extension(s) + } +} + +func (s *Braced_constructor_extensionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitBraced_constructor_extension(s) + } +} + +func (s *Braced_constructor_extensionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitBraced_constructor_extension(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Braced_constructor_extension() (localctx IBraced_constructor_extensionContext) { + localctx = NewBraced_constructor_extensionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1150, GoogleSQLParserRULE_braced_constructor_extension) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6701) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6702) + p.Path_expression() + } + { + p.SetState(6703) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INew_constructorContext is an interface to support dynamic dispatch. +type INew_constructorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + New_constructor_prefix() INew_constructor_prefixContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + New_constructor_prefix_no_arg() INew_constructor_prefix_no_argContext + + // IsNew_constructorContext differentiates from other interfaces. + IsNew_constructorContext() +} + +type New_constructorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNew_constructorContext() *New_constructorContext { + var p = new(New_constructorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_new_constructor + return p +} + +func InitEmptyNew_constructorContext(p *New_constructorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_new_constructor +} + +func (*New_constructorContext) IsNew_constructorContext() {} + +func NewNew_constructorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *New_constructorContext { + var p = new(New_constructorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_new_constructor + + return p +} + +func (s *New_constructorContext) GetParser() antlr.Parser { return s.parser } + +func (s *New_constructorContext) New_constructor_prefix() INew_constructor_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INew_constructor_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INew_constructor_prefixContext) +} + +func (s *New_constructorContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *New_constructorContext) New_constructor_prefix_no_arg() INew_constructor_prefix_no_argContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INew_constructor_prefix_no_argContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INew_constructor_prefix_no_argContext) +} + +func (s *New_constructorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *New_constructorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *New_constructorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterNew_constructor(s) + } +} + +func (s *New_constructorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitNew_constructor(s) + } +} + +func (s *New_constructorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitNew_constructor(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) New_constructor() (localctx INew_constructorContext) { + localctx = NewNew_constructorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1152, GoogleSQLParserRULE_new_constructor) + p.SetState(6711) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 823, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6705) + p.New_constructor_prefix() + } + { + p.SetState(6706) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6708) + p.New_constructor_prefix_no_arg() + } + { + p.SetState(6709) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INew_constructor_prefixContext is an interface to support dynamic dispatch. +type INew_constructor_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + New_constructor_prefix_no_arg() INew_constructor_prefix_no_argContext + AllNew_constructor_arg() []INew_constructor_argContext + New_constructor_arg(i int) INew_constructor_argContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsNew_constructor_prefixContext differentiates from other interfaces. + IsNew_constructor_prefixContext() +} + +type New_constructor_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNew_constructor_prefixContext() *New_constructor_prefixContext { + var p = new(New_constructor_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_new_constructor_prefix + return p +} + +func InitEmptyNew_constructor_prefixContext(p *New_constructor_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_new_constructor_prefix +} + +func (*New_constructor_prefixContext) IsNew_constructor_prefixContext() {} + +func NewNew_constructor_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *New_constructor_prefixContext { + var p = new(New_constructor_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_new_constructor_prefix + + return p +} + +func (s *New_constructor_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *New_constructor_prefixContext) New_constructor_prefix_no_arg() INew_constructor_prefix_no_argContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INew_constructor_prefix_no_argContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INew_constructor_prefix_no_argContext) +} + +func (s *New_constructor_prefixContext) AllNew_constructor_arg() []INew_constructor_argContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INew_constructor_argContext); ok { + len++ + } + } + + tst := make([]INew_constructor_argContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INew_constructor_argContext); ok { + tst[i] = t.(INew_constructor_argContext) + i++ + } + } + + return tst +} + +func (s *New_constructor_prefixContext) New_constructor_arg(i int) INew_constructor_argContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INew_constructor_argContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INew_constructor_argContext) +} + +func (s *New_constructor_prefixContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *New_constructor_prefixContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *New_constructor_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *New_constructor_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *New_constructor_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterNew_constructor_prefix(s) + } +} + +func (s *New_constructor_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitNew_constructor_prefix(s) + } +} + +func (s *New_constructor_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitNew_constructor_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) New_constructor_prefix() (localctx INew_constructor_prefixContext) { + localctx = NewNew_constructor_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1154, GoogleSQLParserRULE_new_constructor_prefix) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6713) + p.New_constructor_prefix_no_arg() + } + { + p.SetState(6714) + p.New_constructor_arg() + } + p.SetState(6719) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(6715) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6716) + p.New_constructor_arg() + } + + p.SetState(6721) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INew_constructor_prefix_no_argContext is an interface to support dynamic dispatch. +type INew_constructor_prefix_no_argContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NEW_SYMBOL() antlr.TerminalNode + Type_name() IType_nameContext + LR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsNew_constructor_prefix_no_argContext differentiates from other interfaces. + IsNew_constructor_prefix_no_argContext() +} + +type New_constructor_prefix_no_argContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNew_constructor_prefix_no_argContext() *New_constructor_prefix_no_argContext { + var p = new(New_constructor_prefix_no_argContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_new_constructor_prefix_no_arg + return p +} + +func InitEmptyNew_constructor_prefix_no_argContext(p *New_constructor_prefix_no_argContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_new_constructor_prefix_no_arg +} + +func (*New_constructor_prefix_no_argContext) IsNew_constructor_prefix_no_argContext() {} + +func NewNew_constructor_prefix_no_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *New_constructor_prefix_no_argContext { + var p = new(New_constructor_prefix_no_argContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_new_constructor_prefix_no_arg + + return p +} + +func (s *New_constructor_prefix_no_argContext) GetParser() antlr.Parser { return s.parser } + +func (s *New_constructor_prefix_no_argContext) NEW_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNEW_SYMBOL, 0) +} + +func (s *New_constructor_prefix_no_argContext) Type_name() IType_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_nameContext) +} + +func (s *New_constructor_prefix_no_argContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *New_constructor_prefix_no_argContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *New_constructor_prefix_no_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *New_constructor_prefix_no_argContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterNew_constructor_prefix_no_arg(s) + } +} + +func (s *New_constructor_prefix_no_argContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitNew_constructor_prefix_no_arg(s) + } +} + +func (s *New_constructor_prefix_no_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitNew_constructor_prefix_no_arg(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) New_constructor_prefix_no_arg() (localctx INew_constructor_prefix_no_argContext) { + localctx = NewNew_constructor_prefix_no_argContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1156, GoogleSQLParserRULE_new_constructor_prefix_no_arg) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6722) + p.Match(GoogleSQLParserNEW_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6723) + p.Type_name() + } + { + p.SetState(6724) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INew_constructor_argContext is an interface to support dynamic dispatch. +type INew_constructor_argContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + AS_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + LR_BRACKET_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + + // IsNew_constructor_argContext differentiates from other interfaces. + IsNew_constructor_argContext() +} + +type New_constructor_argContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNew_constructor_argContext() *New_constructor_argContext { + var p = new(New_constructor_argContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_new_constructor_arg + return p +} + +func InitEmptyNew_constructor_argContext(p *New_constructor_argContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_new_constructor_arg +} + +func (*New_constructor_argContext) IsNew_constructor_argContext() {} + +func NewNew_constructor_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *New_constructor_argContext { + var p = new(New_constructor_argContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_new_constructor_arg + + return p +} + +func (s *New_constructor_argContext) GetParser() antlr.Parser { return s.parser } + +func (s *New_constructor_argContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *New_constructor_argContext) AS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAS_SYMBOL, 0) +} + +func (s *New_constructor_argContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *New_constructor_argContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *New_constructor_argContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *New_constructor_argContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *New_constructor_argContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *New_constructor_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *New_constructor_argContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterNew_constructor_arg(s) + } +} + +func (s *New_constructor_argContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitNew_constructor_arg(s) + } +} + +func (s *New_constructor_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitNew_constructor_arg(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) New_constructor_arg() (localctx INew_constructor_argContext) { + localctx = NewNew_constructor_argContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1158, GoogleSQLParserRULE_new_constructor_arg) + p.SetState(6737) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 825, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6726) + p.expression(0) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6727) + p.expression(0) + } + { + p.SetState(6728) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6729) + p.Identifier() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6731) + p.expression(0) + } + { + p.SetState(6732) + p.Match(GoogleSQLParserAS_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6733) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6734) + p.Path_expression() + } + { + p.SetState(6735) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IArray_constructorContext is an interface to support dynamic dispatch. +type IArray_constructorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Array_constructor_prefix_no_expressions() IArray_constructor_prefix_no_expressionsContext + RS_BRACKET_SYMBOL() antlr.TerminalNode + Array_constructor_prefix() IArray_constructor_prefixContext + + // IsArray_constructorContext differentiates from other interfaces. + IsArray_constructorContext() +} + +type Array_constructorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyArray_constructorContext() *Array_constructorContext { + var p = new(Array_constructorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_array_constructor + return p +} + +func InitEmptyArray_constructorContext(p *Array_constructorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_array_constructor +} + +func (*Array_constructorContext) IsArray_constructorContext() {} + +func NewArray_constructorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Array_constructorContext { + var p = new(Array_constructorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_array_constructor + + return p +} + +func (s *Array_constructorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Array_constructorContext) Array_constructor_prefix_no_expressions() IArray_constructor_prefix_no_expressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArray_constructor_prefix_no_expressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IArray_constructor_prefix_no_expressionsContext) +} + +func (s *Array_constructorContext) RS_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRS_BRACKET_SYMBOL, 0) +} + +func (s *Array_constructorContext) Array_constructor_prefix() IArray_constructor_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArray_constructor_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IArray_constructor_prefixContext) +} + +func (s *Array_constructorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Array_constructorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Array_constructorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterArray_constructor(s) + } +} + +func (s *Array_constructorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitArray_constructor(s) + } +} + +func (s *Array_constructorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitArray_constructor(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Array_constructor() (localctx IArray_constructorContext) { + localctx = NewArray_constructorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1160, GoogleSQLParserRULE_array_constructor) + p.SetState(6745) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 826, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6739) + p.Array_constructor_prefix_no_expressions() + } + { + p.SetState(6740) + p.Match(GoogleSQLParserRS_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6742) + p.Array_constructor_prefix() + } + { + p.SetState(6743) + p.Match(GoogleSQLParserRS_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IArray_constructor_prefixContext is an interface to support dynamic dispatch. +type IArray_constructor_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Array_constructor_prefix_no_expressions() IArray_constructor_prefix_no_expressionsContext + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsArray_constructor_prefixContext differentiates from other interfaces. + IsArray_constructor_prefixContext() +} + +type Array_constructor_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyArray_constructor_prefixContext() *Array_constructor_prefixContext { + var p = new(Array_constructor_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_array_constructor_prefix + return p +} + +func InitEmptyArray_constructor_prefixContext(p *Array_constructor_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_array_constructor_prefix +} + +func (*Array_constructor_prefixContext) IsArray_constructor_prefixContext() {} + +func NewArray_constructor_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Array_constructor_prefixContext { + var p = new(Array_constructor_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_array_constructor_prefix + + return p +} + +func (s *Array_constructor_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Array_constructor_prefixContext) Array_constructor_prefix_no_expressions() IArray_constructor_prefix_no_expressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArray_constructor_prefix_no_expressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IArray_constructor_prefix_no_expressionsContext) +} + +func (s *Array_constructor_prefixContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Array_constructor_prefixContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Array_constructor_prefixContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Array_constructor_prefixContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Array_constructor_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Array_constructor_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Array_constructor_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterArray_constructor_prefix(s) + } +} + +func (s *Array_constructor_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitArray_constructor_prefix(s) + } +} + +func (s *Array_constructor_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitArray_constructor_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Array_constructor_prefix() (localctx IArray_constructor_prefixContext) { + localctx = NewArray_constructor_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1162, GoogleSQLParserRULE_array_constructor_prefix) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6747) + p.Array_constructor_prefix_no_expressions() + } + { + p.SetState(6748) + p.expression(0) + } + p.SetState(6753) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(6749) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6750) + p.expression(0) + } + + p.SetState(6755) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IArray_constructor_prefix_no_expressionsContext is an interface to support dynamic dispatch. +type IArray_constructor_prefix_no_expressionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ARRAY_SYMBOL() antlr.TerminalNode + LS_BRACKET_SYMBOL() antlr.TerminalNode + Array_type() IArray_typeContext + + // IsArray_constructor_prefix_no_expressionsContext differentiates from other interfaces. + IsArray_constructor_prefix_no_expressionsContext() +} + +type Array_constructor_prefix_no_expressionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyArray_constructor_prefix_no_expressionsContext() *Array_constructor_prefix_no_expressionsContext { + var p = new(Array_constructor_prefix_no_expressionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_array_constructor_prefix_no_expressions + return p +} + +func InitEmptyArray_constructor_prefix_no_expressionsContext(p *Array_constructor_prefix_no_expressionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_array_constructor_prefix_no_expressions +} + +func (*Array_constructor_prefix_no_expressionsContext) IsArray_constructor_prefix_no_expressionsContext() { +} + +func NewArray_constructor_prefix_no_expressionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Array_constructor_prefix_no_expressionsContext { + var p = new(Array_constructor_prefix_no_expressionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_array_constructor_prefix_no_expressions + + return p +} + +func (s *Array_constructor_prefix_no_expressionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Array_constructor_prefix_no_expressionsContext) ARRAY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserARRAY_SYMBOL, 0) +} + +func (s *Array_constructor_prefix_no_expressionsContext) LS_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLS_BRACKET_SYMBOL, 0) +} + +func (s *Array_constructor_prefix_no_expressionsContext) Array_type() IArray_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArray_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IArray_typeContext) +} + +func (s *Array_constructor_prefix_no_expressionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Array_constructor_prefix_no_expressionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Array_constructor_prefix_no_expressionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterArray_constructor_prefix_no_expressions(s) + } +} + +func (s *Array_constructor_prefix_no_expressionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitArray_constructor_prefix_no_expressions(s) + } +} + +func (s *Array_constructor_prefix_no_expressionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitArray_constructor_prefix_no_expressions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Array_constructor_prefix_no_expressions() (localctx IArray_constructor_prefix_no_expressionsContext) { + localctx = NewArray_constructor_prefix_no_expressionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1164, GoogleSQLParserRULE_array_constructor_prefix_no_expressions) + p.SetState(6762) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 828, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6756) + p.Match(GoogleSQLParserARRAY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6757) + p.Match(GoogleSQLParserLS_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6758) + p.Match(GoogleSQLParserLS_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6759) + p.Array_type() + } + { + p.SetState(6760) + p.Match(GoogleSQLParserLS_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRange_literalContext is an interface to support dynamic dispatch. +type IRange_literalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Range_type() IRange_typeContext + String_literal() IString_literalContext + + // IsRange_literalContext differentiates from other interfaces. + IsRange_literalContext() +} + +type Range_literalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRange_literalContext() *Range_literalContext { + var p = new(Range_literalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_range_literal + return p +} + +func InitEmptyRange_literalContext(p *Range_literalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_range_literal +} + +func (*Range_literalContext) IsRange_literalContext() {} + +func NewRange_literalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Range_literalContext { + var p = new(Range_literalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_range_literal + + return p +} + +func (s *Range_literalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Range_literalContext) Range_type() IRange_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRange_typeContext) +} + +func (s *Range_literalContext) String_literal() IString_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_literalContext) +} + +func (s *Range_literalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Range_literalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Range_literalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterRange_literal(s) + } +} + +func (s *Range_literalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitRange_literal(s) + } +} + +func (s *Range_literalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitRange_literal(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Range_literal() (localctx IRange_literalContext) { + localctx = NewRange_literalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1166, GoogleSQLParserRULE_range_literal) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6764) + p.Range_type() + } + { + p.SetState(6765) + p.string_literal(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRange_typeContext is an interface to support dynamic dispatch. +type IRange_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RANGE_SYMBOL() antlr.TerminalNode + Template_type_open() ITemplate_type_openContext + Type_() ITypeContext + Template_type_close() ITemplate_type_closeContext + + // IsRange_typeContext differentiates from other interfaces. + IsRange_typeContext() +} + +type Range_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRange_typeContext() *Range_typeContext { + var p = new(Range_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_range_type + return p +} + +func InitEmptyRange_typeContext(p *Range_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_range_type +} + +func (*Range_typeContext) IsRange_typeContext() {} + +func NewRange_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Range_typeContext { + var p = new(Range_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_range_type + + return p +} + +func (s *Range_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Range_typeContext) RANGE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRANGE_SYMBOL, 0) +} + +func (s *Range_typeContext) Template_type_open() ITemplate_type_openContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemplate_type_openContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemplate_type_openContext) +} + +func (s *Range_typeContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *Range_typeContext) Template_type_close() ITemplate_type_closeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemplate_type_closeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemplate_type_closeContext) +} + +func (s *Range_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Range_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Range_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterRange_type(s) + } +} + +func (s *Range_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitRange_type(s) + } +} + +func (s *Range_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitRange_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Range_type() (localctx IRange_typeContext) { + localctx = NewRange_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1168, GoogleSQLParserRULE_range_type) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6767) + p.Match(GoogleSQLParserRANGE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6768) + p.Template_type_open() + } + { + p.SetState(6769) + p.Type_() + } + { + p.SetState(6770) + p.Template_type_close() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITypeContext is an interface to support dynamic dispatch. +type ITypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Raw_type() IRaw_typeContext + Opt_type_parameters() IOpt_type_parametersContext + Collate_clause() ICollate_clauseContext + + // IsTypeContext differentiates from other interfaces. + IsTypeContext() +} + +type TypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTypeContext() *TypeContext { + var p = new(TypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_type + return p +} + +func InitEmptyTypeContext(p *TypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_type +} + +func (*TypeContext) IsTypeContext() {} + +func NewTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeContext { + var p = new(TypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_type + + return p +} + +func (s *TypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *TypeContext) Raw_type() IRaw_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRaw_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRaw_typeContext) +} + +func (s *TypeContext) Opt_type_parameters() IOpt_type_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_type_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_type_parametersContext) +} + +func (s *TypeContext) Collate_clause() ICollate_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollate_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollate_clauseContext) +} + +func (s *TypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterType(s) + } +} + +func (s *TypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitType(s) + } +} + +func (s *TypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitType(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Type_() (localctx ITypeContext) { + localctx = NewTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1170, GoogleSQLParserRULE_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6772) + p.Raw_type() + } + p.SetState(6774) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserLR_BRACKET_SYMBOL { + { + p.SetState(6773) + p.Opt_type_parameters() + } + + } + p.SetState(6777) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == GoogleSQLParserCOLLATE_SYMBOL { + { + p.SetState(6776) + p.Collate_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICollate_clauseContext is an interface to support dynamic dispatch. +type ICollate_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COLLATE_SYMBOL() antlr.TerminalNode + String_literal_or_parameter() IString_literal_or_parameterContext + + // IsCollate_clauseContext differentiates from other interfaces. + IsCollate_clauseContext() +} + +type Collate_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCollate_clauseContext() *Collate_clauseContext { + var p = new(Collate_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_collate_clause + return p +} + +func InitEmptyCollate_clauseContext(p *Collate_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_collate_clause +} + +func (*Collate_clauseContext) IsCollate_clauseContext() {} + +func NewCollate_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Collate_clauseContext { + var p = new(Collate_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_collate_clause + + return p +} + +func (s *Collate_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Collate_clauseContext) COLLATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOLLATE_SYMBOL, 0) +} + +func (s *Collate_clauseContext) String_literal_or_parameter() IString_literal_or_parameterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_literal_or_parameterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_literal_or_parameterContext) +} + +func (s *Collate_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Collate_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Collate_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCollate_clause(s) + } +} + +func (s *Collate_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCollate_clause(s) + } +} + +func (s *Collate_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCollate_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Collate_clause() (localctx ICollate_clauseContext) { + localctx = NewCollate_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1172, GoogleSQLParserRULE_collate_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6779) + p.Match(GoogleSQLParserCOLLATE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6780) + p.String_literal_or_parameter() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IString_literal_or_parameterContext is an interface to support dynamic dispatch. +type IString_literal_or_parameterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + String_literal() IString_literalContext + Parameter_expression() IParameter_expressionContext + System_variable_expression() ISystem_variable_expressionContext + + // IsString_literal_or_parameterContext differentiates from other interfaces. + IsString_literal_or_parameterContext() +} + +type String_literal_or_parameterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyString_literal_or_parameterContext() *String_literal_or_parameterContext { + var p = new(String_literal_or_parameterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_string_literal_or_parameter + return p +} + +func InitEmptyString_literal_or_parameterContext(p *String_literal_or_parameterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_string_literal_or_parameter +} + +func (*String_literal_or_parameterContext) IsString_literal_or_parameterContext() {} + +func NewString_literal_or_parameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *String_literal_or_parameterContext { + var p = new(String_literal_or_parameterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_string_literal_or_parameter + + return p +} + +func (s *String_literal_or_parameterContext) GetParser() antlr.Parser { return s.parser } + +func (s *String_literal_or_parameterContext) String_literal() IString_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_literalContext) +} + +func (s *String_literal_or_parameterContext) Parameter_expression() IParameter_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameter_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameter_expressionContext) +} + +func (s *String_literal_or_parameterContext) System_variable_expression() ISystem_variable_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISystem_variable_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISystem_variable_expressionContext) +} + +func (s *String_literal_or_parameterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *String_literal_or_parameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *String_literal_or_parameterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterString_literal_or_parameter(s) + } +} + +func (s *String_literal_or_parameterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitString_literal_or_parameter(s) + } +} + +func (s *String_literal_or_parameterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitString_literal_or_parameter(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) String_literal_or_parameter() (localctx IString_literal_or_parameterContext) { + localctx = NewString_literal_or_parameterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1174, GoogleSQLParserRULE_string_literal_or_parameter) + p.SetState(6785) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserSTRING_LITERAL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6782) + p.string_literal(0) + } + + case GoogleSQLParserQUESTION_SYMBOL, GoogleSQLParserAT_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6783) + p.Parameter_expression() + } + + case GoogleSQLParserATAT_SYMBOL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6784) + p.System_variable_expression() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISystem_variable_expressionContext is an interface to support dynamic dispatch. +type ISystem_variable_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ATAT_SYMBOL() antlr.TerminalNode + Path_expression() IPath_expressionContext + + // IsSystem_variable_expressionContext differentiates from other interfaces. + IsSystem_variable_expressionContext() +} + +type System_variable_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySystem_variable_expressionContext() *System_variable_expressionContext { + var p = new(System_variable_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_system_variable_expression + return p +} + +func InitEmptySystem_variable_expressionContext(p *System_variable_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_system_variable_expression +} + +func (*System_variable_expressionContext) IsSystem_variable_expressionContext() {} + +func NewSystem_variable_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *System_variable_expressionContext { + var p = new(System_variable_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_system_variable_expression + + return p +} + +func (s *System_variable_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *System_variable_expressionContext) ATAT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserATAT_SYMBOL, 0) +} + +func (s *System_variable_expressionContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *System_variable_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *System_variable_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *System_variable_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterSystem_variable_expression(s) + } +} + +func (s *System_variable_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitSystem_variable_expression(s) + } +} + +func (s *System_variable_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitSystem_variable_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) System_variable_expression() (localctx ISystem_variable_expressionContext) { + localctx = NewSystem_variable_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1176, GoogleSQLParserRULE_system_variable_expression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6787) + p.Match(GoogleSQLParserATAT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6788) + p.Path_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParameter_expressionContext is an interface to support dynamic dispatch. +type IParameter_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Named_parameter_expression() INamed_parameter_expressionContext + QUESTION_SYMBOL() antlr.TerminalNode + + // IsParameter_expressionContext differentiates from other interfaces. + IsParameter_expressionContext() +} + +type Parameter_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParameter_expressionContext() *Parameter_expressionContext { + var p = new(Parameter_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_parameter_expression + return p +} + +func InitEmptyParameter_expressionContext(p *Parameter_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_parameter_expression +} + +func (*Parameter_expressionContext) IsParameter_expressionContext() {} + +func NewParameter_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Parameter_expressionContext { + var p = new(Parameter_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_parameter_expression + + return p +} + +func (s *Parameter_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Parameter_expressionContext) Named_parameter_expression() INamed_parameter_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INamed_parameter_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INamed_parameter_expressionContext) +} + +func (s *Parameter_expressionContext) QUESTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserQUESTION_SYMBOL, 0) +} + +func (s *Parameter_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Parameter_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Parameter_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterParameter_expression(s) + } +} + +func (s *Parameter_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitParameter_expression(s) + } +} + +func (s *Parameter_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitParameter_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Parameter_expression() (localctx IParameter_expressionContext) { + localctx = NewParameter_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1178, GoogleSQLParserRULE_parameter_expression) + p.SetState(6792) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserAT_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6790) + p.Named_parameter_expression() + } + + case GoogleSQLParserQUESTION_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6791) + p.Match(GoogleSQLParserQUESTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INamed_parameter_expressionContext is an interface to support dynamic dispatch. +type INamed_parameter_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AT_SYMBOL() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsNamed_parameter_expressionContext differentiates from other interfaces. + IsNamed_parameter_expressionContext() +} + +type Named_parameter_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNamed_parameter_expressionContext() *Named_parameter_expressionContext { + var p = new(Named_parameter_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_named_parameter_expression + return p +} + +func InitEmptyNamed_parameter_expressionContext(p *Named_parameter_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_named_parameter_expression +} + +func (*Named_parameter_expressionContext) IsNamed_parameter_expressionContext() {} + +func NewNamed_parameter_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Named_parameter_expressionContext { + var p = new(Named_parameter_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_named_parameter_expression + + return p +} + +func (s *Named_parameter_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Named_parameter_expressionContext) AT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAT_SYMBOL, 0) +} + +func (s *Named_parameter_expressionContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Named_parameter_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Named_parameter_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Named_parameter_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterNamed_parameter_expression(s) + } +} + +func (s *Named_parameter_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitNamed_parameter_expression(s) + } +} + +func (s *Named_parameter_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitNamed_parameter_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Named_parameter_expression() (localctx INamed_parameter_expressionContext) { + localctx = NewNamed_parameter_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1180, GoogleSQLParserRULE_named_parameter_expression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6794) + p.Match(GoogleSQLParserAT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6795) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_type_parametersContext is an interface to support dynamic dispatch. +type IOpt_type_parametersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Type_parameters_prefix() IType_parameters_prefixContext + RR_BRACKET_SYMBOL() antlr.TerminalNode + COMMA_SYMBOL() antlr.TerminalNode + + // IsOpt_type_parametersContext differentiates from other interfaces. + IsOpt_type_parametersContext() +} + +type Opt_type_parametersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_type_parametersContext() *Opt_type_parametersContext { + var p = new(Opt_type_parametersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_type_parameters + return p +} + +func InitEmptyOpt_type_parametersContext(p *Opt_type_parametersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_opt_type_parameters +} + +func (*Opt_type_parametersContext) IsOpt_type_parametersContext() {} + +func NewOpt_type_parametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_type_parametersContext { + var p = new(Opt_type_parametersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_opt_type_parameters + + return p +} + +func (s *Opt_type_parametersContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_type_parametersContext) Type_parameters_prefix() IType_parameters_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_parameters_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_parameters_prefixContext) +} + +func (s *Opt_type_parametersContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Opt_type_parametersContext) COMMA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, 0) +} + +func (s *Opt_type_parametersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_type_parametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_type_parametersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterOpt_type_parameters(s) + } +} + +func (s *Opt_type_parametersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitOpt_type_parameters(s) + } +} + +func (s *Opt_type_parametersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitOpt_type_parameters(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Opt_type_parameters() (localctx IOpt_type_parametersContext) { + localctx = NewOpt_type_parametersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1182, GoogleSQLParserRULE_opt_type_parameters) + p.SetState(6805) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 833, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6797) + p.Type_parameters_prefix() + } + { + p.SetState(6798) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6800) + p.Type_parameters_prefix() + } + { + p.SetState(6801) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6802) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.NotifyErrorListeners("Syntax error: Trailing comma in type parameters list is not allowed.", nil, nil) + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IType_parameters_prefixContext is an interface to support dynamic dispatch. +type IType_parameters_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET_SYMBOL() antlr.TerminalNode + AllType_parameter() []IType_parameterContext + Type_parameter(i int) IType_parameterContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsType_parameters_prefixContext differentiates from other interfaces. + IsType_parameters_prefixContext() +} + +type Type_parameters_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_parameters_prefixContext() *Type_parameters_prefixContext { + var p = new(Type_parameters_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_type_parameters_prefix + return p +} + +func InitEmptyType_parameters_prefixContext(p *Type_parameters_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_type_parameters_prefix +} + +func (*Type_parameters_prefixContext) IsType_parameters_prefixContext() {} + +func NewType_parameters_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_parameters_prefixContext { + var p = new(Type_parameters_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_type_parameters_prefix + + return p +} + +func (s *Type_parameters_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_parameters_prefixContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Type_parameters_prefixContext) AllType_parameter() []IType_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_parameterContext); ok { + len++ + } + } + + tst := make([]IType_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_parameterContext); ok { + tst[i] = t.(IType_parameterContext) + i++ + } + } + + return tst +} + +func (s *Type_parameters_prefixContext) Type_parameter(i int) IType_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_parameterContext) +} + +func (s *Type_parameters_prefixContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Type_parameters_prefixContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Type_parameters_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_parameters_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_parameters_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterType_parameters_prefix(s) + } +} + +func (s *Type_parameters_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitType_parameters_prefix(s) + } +} + +func (s *Type_parameters_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitType_parameters_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Type_parameters_prefix() (localctx IType_parameters_prefixContext) { + localctx = NewType_parameters_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1184, GoogleSQLParserRULE_type_parameters_prefix) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6807) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6808) + p.Type_parameter() + } + p.SetState(6813) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 834, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(6809) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6810) + p.Type_parameter() + } + + } + p.SetState(6815) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 834, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IType_parameterContext is an interface to support dynamic dispatch. +type IType_parameterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Integer_literal() IInteger_literalContext + Boolean_literal() IBoolean_literalContext + String_literal() IString_literalContext + Bytes_literal() IBytes_literalContext + Floating_point_literal() IFloating_point_literalContext + MAX_SYMBOL() antlr.TerminalNode + + // IsType_parameterContext differentiates from other interfaces. + IsType_parameterContext() +} + +type Type_parameterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_parameterContext() *Type_parameterContext { + var p = new(Type_parameterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_type_parameter + return p +} + +func InitEmptyType_parameterContext(p *Type_parameterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_type_parameter +} + +func (*Type_parameterContext) IsType_parameterContext() {} + +func NewType_parameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_parameterContext { + var p = new(Type_parameterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_type_parameter + + return p +} + +func (s *Type_parameterContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_parameterContext) Integer_literal() IInteger_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInteger_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInteger_literalContext) +} + +func (s *Type_parameterContext) Boolean_literal() IBoolean_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBoolean_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBoolean_literalContext) +} + +func (s *Type_parameterContext) String_literal() IString_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_literalContext) +} + +func (s *Type_parameterContext) Bytes_literal() IBytes_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBytes_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBytes_literalContext) +} + +func (s *Type_parameterContext) Floating_point_literal() IFloating_point_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFloating_point_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFloating_point_literalContext) +} + +func (s *Type_parameterContext) MAX_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMAX_SYMBOL, 0) +} + +func (s *Type_parameterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_parameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_parameterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterType_parameter(s) + } +} + +func (s *Type_parameterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitType_parameter(s) + } +} + +func (s *Type_parameterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitType_parameter(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Type_parameter() (localctx IType_parameterContext) { + localctx = NewType_parameterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1186, GoogleSQLParserRULE_type_parameter) + p.SetState(6822) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserINTEGER_LITERAL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6816) + p.Integer_literal() + } + + case GoogleSQLParserTRUE_SYMBOL, GoogleSQLParserFALSE_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6817) + p.Boolean_literal() + } + + case GoogleSQLParserSTRING_LITERAL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6818) + p.string_literal(0) + } + + case GoogleSQLParserBYTES_LITERAL: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6819) + p.bytes_literal(0) + } + + case GoogleSQLParserFLOATING_POINT_LITERAL: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6820) + p.Floating_point_literal() + } + + case GoogleSQLParserMAX_SYMBOL: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6821) + p.Match(GoogleSQLParserMAX_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRaw_typeContext is an interface to support dynamic dispatch. +type IRaw_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Array_type() IArray_typeContext + Struct_type() IStruct_typeContext + Type_name() IType_nameContext + Range_type() IRange_typeContext + Function_type() IFunction_typeContext + Map_type() IMap_typeContext + + // IsRaw_typeContext differentiates from other interfaces. + IsRaw_typeContext() +} + +type Raw_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRaw_typeContext() *Raw_typeContext { + var p = new(Raw_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_raw_type + return p +} + +func InitEmptyRaw_typeContext(p *Raw_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_raw_type +} + +func (*Raw_typeContext) IsRaw_typeContext() {} + +func NewRaw_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Raw_typeContext { + var p = new(Raw_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_raw_type + + return p +} + +func (s *Raw_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Raw_typeContext) Array_type() IArray_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArray_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IArray_typeContext) +} + +func (s *Raw_typeContext) Struct_type() IStruct_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStruct_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStruct_typeContext) +} + +func (s *Raw_typeContext) Type_name() IType_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_nameContext) +} + +func (s *Raw_typeContext) Range_type() IRange_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRange_typeContext) +} + +func (s *Raw_typeContext) Function_type() IFunction_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_typeContext) +} + +func (s *Raw_typeContext) Map_type() IMap_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMap_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMap_typeContext) +} + +func (s *Raw_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Raw_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Raw_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterRaw_type(s) + } +} + +func (s *Raw_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitRaw_type(s) + } +} + +func (s *Raw_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitRaw_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Raw_type() (localctx IRaw_typeContext) { + localctx = NewRaw_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1188, GoogleSQLParserRULE_raw_type) + p.SetState(6830) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 836, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6824) + p.Array_type() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6825) + p.Struct_type() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6826) + p.Type_name() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6827) + p.Range_type() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6828) + p.Function_type() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6829) + p.Map_type() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMap_typeContext is an interface to support dynamic dispatch. +type IMap_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetKey_type returns the key_type rule contexts. + GetKey_type() ITypeContext + + // GetValue_type returns the value_type rule contexts. + GetValue_type() ITypeContext + + // SetKey_type sets the key_type rule contexts. + SetKey_type(ITypeContext) + + // SetValue_type sets the value_type rule contexts. + SetValue_type(ITypeContext) + + // Getter signatures + MAP_SYMBOL() antlr.TerminalNode + Template_type_open() ITemplate_type_openContext + COMMA_SYMBOL() antlr.TerminalNode + Template_type_close() ITemplate_type_closeContext + AllType_() []ITypeContext + Type_(i int) ITypeContext + + // IsMap_typeContext differentiates from other interfaces. + IsMap_typeContext() +} + +type Map_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + key_type ITypeContext + value_type ITypeContext +} + +func NewEmptyMap_typeContext() *Map_typeContext { + var p = new(Map_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_map_type + return p +} + +func InitEmptyMap_typeContext(p *Map_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_map_type +} + +func (*Map_typeContext) IsMap_typeContext() {} + +func NewMap_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Map_typeContext { + var p = new(Map_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_map_type + + return p +} + +func (s *Map_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Map_typeContext) GetKey_type() ITypeContext { return s.key_type } + +func (s *Map_typeContext) GetValue_type() ITypeContext { return s.value_type } + +func (s *Map_typeContext) SetKey_type(v ITypeContext) { s.key_type = v } + +func (s *Map_typeContext) SetValue_type(v ITypeContext) { s.value_type = v } + +func (s *Map_typeContext) MAP_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMAP_SYMBOL, 0) +} + +func (s *Map_typeContext) Template_type_open() ITemplate_type_openContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemplate_type_openContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemplate_type_openContext) +} + +func (s *Map_typeContext) COMMA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, 0) +} + +func (s *Map_typeContext) Template_type_close() ITemplate_type_closeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemplate_type_closeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemplate_type_closeContext) +} + +func (s *Map_typeContext) AllType_() []ITypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypeContext); ok { + len++ + } + } + + tst := make([]ITypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypeContext); ok { + tst[i] = t.(ITypeContext) + i++ + } + } + + return tst +} + +func (s *Map_typeContext) Type_(i int) ITypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *Map_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Map_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Map_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterMap_type(s) + } +} + +func (s *Map_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitMap_type(s) + } +} + +func (s *Map_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitMap_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Map_type() (localctx IMap_typeContext) { + localctx = NewMap_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1190, GoogleSQLParserRULE_map_type) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6832) + p.Match(GoogleSQLParserMAP_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6833) + p.Template_type_open() + } + { + p.SetState(6834) + + var _x = p.Type_() + + localctx.(*Map_typeContext).key_type = _x + } + { + p.SetState(6835) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6836) + + var _x = p.Type_() + + localctx.(*Map_typeContext).value_type = _x + } + { + p.SetState(6837) + p.Template_type_close() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunction_typeContext is an interface to support dynamic dispatch. +type IFunction_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetReturn_type returns the return_type rule contexts. + GetReturn_type() ITypeContext + + // GetArg_type returns the arg_type rule contexts. + GetArg_type() ITypeContext + + // GetArg_list returns the arg_list rule contexts. + GetArg_list() IFunction_type_prefixContext + + // SetReturn_type sets the return_type rule contexts. + SetReturn_type(ITypeContext) + + // SetArg_type sets the arg_type rule contexts. + SetArg_type(ITypeContext) + + // SetArg_list sets the arg_list rule contexts. + SetArg_list(IFunction_type_prefixContext) + + // Getter signatures + FUNCTION_SYMBOL() antlr.TerminalNode + Template_type_open() ITemplate_type_openContext + LR_BRACKET_SYMBOL() antlr.TerminalNode + RR_BRACKET_SYMBOL() antlr.TerminalNode + SUB_GT_BRACKET_SYMBOL() antlr.TerminalNode + Template_type_close() ITemplate_type_closeContext + AllType_() []ITypeContext + Type_(i int) ITypeContext + Function_type_prefix() IFunction_type_prefixContext + + // IsFunction_typeContext differentiates from other interfaces. + IsFunction_typeContext() +} + +type Function_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + return_type ITypeContext + arg_type ITypeContext + arg_list IFunction_type_prefixContext +} + +func NewEmptyFunction_typeContext() *Function_typeContext { + var p = new(Function_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_function_type + return p +} + +func InitEmptyFunction_typeContext(p *Function_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_function_type +} + +func (*Function_typeContext) IsFunction_typeContext() {} + +func NewFunction_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_typeContext { + var p = new(Function_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_function_type + + return p +} + +func (s *Function_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_typeContext) GetReturn_type() ITypeContext { return s.return_type } + +func (s *Function_typeContext) GetArg_type() ITypeContext { return s.arg_type } + +func (s *Function_typeContext) GetArg_list() IFunction_type_prefixContext { return s.arg_list } + +func (s *Function_typeContext) SetReturn_type(v ITypeContext) { s.return_type = v } + +func (s *Function_typeContext) SetArg_type(v ITypeContext) { s.arg_type = v } + +func (s *Function_typeContext) SetArg_list(v IFunction_type_prefixContext) { s.arg_list = v } + +func (s *Function_typeContext) FUNCTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFUNCTION_SYMBOL, 0) +} + +func (s *Function_typeContext) Template_type_open() ITemplate_type_openContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemplate_type_openContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemplate_type_openContext) +} + +func (s *Function_typeContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Function_typeContext) RR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRR_BRACKET_SYMBOL, 0) +} + +func (s *Function_typeContext) SUB_GT_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSUB_GT_BRACKET_SYMBOL, 0) +} + +func (s *Function_typeContext) Template_type_close() ITemplate_type_closeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemplate_type_closeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemplate_type_closeContext) +} + +func (s *Function_typeContext) AllType_() []ITypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypeContext); ok { + len++ + } + } + + tst := make([]ITypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypeContext); ok { + tst[i] = t.(ITypeContext) + i++ + } + } + + return tst +} + +func (s *Function_typeContext) Type_(i int) ITypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *Function_typeContext) Function_type_prefix() IFunction_type_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_type_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_type_prefixContext) +} + +func (s *Function_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterFunction_type(s) + } +} + +func (s *Function_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitFunction_type(s) + } +} + +func (s *Function_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitFunction_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Function_type() (localctx IFunction_typeContext) { + localctx = NewFunction_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1192, GoogleSQLParserRULE_function_type) + p.SetState(6860) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 837, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6839) + p.Match(GoogleSQLParserFUNCTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6840) + p.Template_type_open() + } + { + p.SetState(6841) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6842) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6843) + p.Match(GoogleSQLParserSUB_GT_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6844) + + var _x = p.Type_() + + localctx.(*Function_typeContext).return_type = _x + } + { + p.SetState(6845) + p.Template_type_close() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6847) + p.Match(GoogleSQLParserFUNCTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6848) + p.Template_type_open() + } + { + p.SetState(6849) + + var _x = p.Type_() + + localctx.(*Function_typeContext).arg_type = _x + } + { + p.SetState(6850) + p.Match(GoogleSQLParserSUB_GT_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6851) + + var _x = p.Type_() + + localctx.(*Function_typeContext).return_type = _x + } + { + p.SetState(6852) + p.Template_type_close() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6854) + + var _x = p.Function_type_prefix() + + localctx.(*Function_typeContext).arg_list = _x + } + { + p.SetState(6855) + p.Match(GoogleSQLParserRR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6856) + p.Match(GoogleSQLParserSUB_GT_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6857) + + var _x = p.Type_() + + localctx.(*Function_typeContext).return_type = _x + } + { + p.SetState(6858) + p.Template_type_close() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunction_type_prefixContext is an interface to support dynamic dispatch. +type IFunction_type_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FUNCTION_SYMBOL() antlr.TerminalNode + Template_type_open() ITemplate_type_openContext + LR_BRACKET_SYMBOL() antlr.TerminalNode + AllType_() []ITypeContext + Type_(i int) ITypeContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsFunction_type_prefixContext differentiates from other interfaces. + IsFunction_type_prefixContext() +} + +type Function_type_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_type_prefixContext() *Function_type_prefixContext { + var p = new(Function_type_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_function_type_prefix + return p +} + +func InitEmptyFunction_type_prefixContext(p *Function_type_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_function_type_prefix +} + +func (*Function_type_prefixContext) IsFunction_type_prefixContext() {} + +func NewFunction_type_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_type_prefixContext { + var p = new(Function_type_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_function_type_prefix + + return p +} + +func (s *Function_type_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_type_prefixContext) FUNCTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFUNCTION_SYMBOL, 0) +} + +func (s *Function_type_prefixContext) Template_type_open() ITemplate_type_openContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemplate_type_openContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemplate_type_openContext) +} + +func (s *Function_type_prefixContext) LR_BRACKET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLR_BRACKET_SYMBOL, 0) +} + +func (s *Function_type_prefixContext) AllType_() []ITypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypeContext); ok { + len++ + } + } + + tst := make([]ITypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypeContext); ok { + tst[i] = t.(ITypeContext) + i++ + } + } + + return tst +} + +func (s *Function_type_prefixContext) Type_(i int) ITypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *Function_type_prefixContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Function_type_prefixContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Function_type_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_type_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_type_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterFunction_type_prefix(s) + } +} + +func (s *Function_type_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitFunction_type_prefix(s) + } +} + +func (s *Function_type_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitFunction_type_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Function_type_prefix() (localctx IFunction_type_prefixContext) { + localctx = NewFunction_type_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1194, GoogleSQLParserRULE_function_type_prefix) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6862) + p.Match(GoogleSQLParserFUNCTION_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6863) + p.Template_type_open() + } + { + p.SetState(6864) + p.Match(GoogleSQLParserLR_BRACKET_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6865) + p.Type_() + } + p.SetState(6870) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(6866) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6867) + p.Type_() + } + + p.SetState(6872) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IType_nameContext is an interface to support dynamic dispatch. +type IType_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Path_expression() IPath_expressionContext + INTERVAL_SYMBOL() antlr.TerminalNode + + // IsType_nameContext differentiates from other interfaces. + IsType_nameContext() +} + +type Type_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_nameContext() *Type_nameContext { + var p = new(Type_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_type_name + return p +} + +func InitEmptyType_nameContext(p *Type_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_type_name +} + +func (*Type_nameContext) IsType_nameContext() {} + +func NewType_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_nameContext { + var p = new(Type_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_type_name + + return p +} + +func (s *Type_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_nameContext) Path_expression() IPath_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPath_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPath_expressionContext) +} + +func (s *Type_nameContext) INTERVAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINTERVAL_SYMBOL, 0) +} + +func (s *Type_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterType_name(s) + } +} + +func (s *Type_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitType_name(s) + } +} + +func (s *Type_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitType_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Type_name() (localctx IType_nameContext) { + localctx = NewType_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1196, GoogleSQLParserRULE_type_name) + p.SetState(6875) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL, GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6873) + p.Path_expression() + } + + case GoogleSQLParserINTERVAL_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6874) + p.Match(GoogleSQLParserINTERVAL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPath_expressionContext is an interface to support dynamic dispatch. +type IPath_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + AllDOT_SYMBOL() []antlr.TerminalNode + DOT_SYMBOL(i int) antlr.TerminalNode + + // IsPath_expressionContext differentiates from other interfaces. + IsPath_expressionContext() +} + +type Path_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPath_expressionContext() *Path_expressionContext { + var p = new(Path_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_path_expression + return p +} + +func InitEmptyPath_expressionContext(p *Path_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_path_expression +} + +func (*Path_expressionContext) IsPath_expressionContext() {} + +func NewPath_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Path_expressionContext { + var p = new(Path_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_path_expression + + return p +} + +func (s *Path_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Path_expressionContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Path_expressionContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Path_expressionContext) AllDOT_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserDOT_SYMBOL) +} + +func (s *Path_expressionContext) DOT_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDOT_SYMBOL, i) +} + +func (s *Path_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Path_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Path_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterPath_expression(s) + } +} + +func (s *Path_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitPath_expression(s) + } +} + +func (s *Path_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitPath_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Path_expression() (localctx IPath_expressionContext) { + localctx = NewPath_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1198, GoogleSQLParserRULE_path_expression) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6877) + p.Identifier() + } + p.SetState(6882) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 840, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(6878) + p.Match(GoogleSQLParserDOT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6879) + p.Identifier() + } + + } + p.SetState(6884) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 840, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentifierContext is an interface to support dynamic dispatch. +type IIdentifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Token_identifier() IToken_identifierContext + Keyword_as_identifier() IKeyword_as_identifierContext + + // IsIdentifierContext differentiates from other interfaces. + IsIdentifierContext() +} + +type IdentifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentifierContext() *IdentifierContext { + var p = new(IdentifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_identifier + return p +} + +func InitEmptyIdentifierContext(p *IdentifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_identifier +} + +func (*IdentifierContext) IsIdentifierContext() {} + +func NewIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifierContext { + var p = new(IdentifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_identifier + + return p +} + +func (s *IdentifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *IdentifierContext) Token_identifier() IToken_identifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IToken_identifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IToken_identifierContext) +} + +func (s *IdentifierContext) Keyword_as_identifier() IKeyword_as_identifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyword_as_identifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyword_as_identifierContext) +} + +func (s *IdentifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IdentifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterIdentifier(s) + } +} + +func (s *IdentifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitIdentifier(s) + } +} + +func (s *IdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitIdentifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Identifier() (localctx IIdentifierContext) { + localctx = NewIdentifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1200, GoogleSQLParserRULE_identifier) + p.SetState(6887) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6885) + p.Token_identifier() + } + + case GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserSIMPLE_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6886) + p.Keyword_as_identifier() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKeyword_as_identifierContext is an interface to support dynamic dispatch. +type IKeyword_as_identifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Common_keyword_as_identifier() ICommon_keyword_as_identifierContext + SIMPLE_SYMBOL() antlr.TerminalNode + + // IsKeyword_as_identifierContext differentiates from other interfaces. + IsKeyword_as_identifierContext() +} + +type Keyword_as_identifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKeyword_as_identifierContext() *Keyword_as_identifierContext { + var p = new(Keyword_as_identifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_keyword_as_identifier + return p +} + +func InitEmptyKeyword_as_identifierContext(p *Keyword_as_identifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_keyword_as_identifier +} + +func (*Keyword_as_identifierContext) IsKeyword_as_identifierContext() {} + +func NewKeyword_as_identifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Keyword_as_identifierContext { + var p = new(Keyword_as_identifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_keyword_as_identifier + + return p +} + +func (s *Keyword_as_identifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *Keyword_as_identifierContext) Common_keyword_as_identifier() ICommon_keyword_as_identifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommon_keyword_as_identifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommon_keyword_as_identifierContext) +} + +func (s *Keyword_as_identifierContext) SIMPLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSIMPLE_SYMBOL, 0) +} + +func (s *Keyword_as_identifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Keyword_as_identifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Keyword_as_identifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterKeyword_as_identifier(s) + } +} + +func (s *Keyword_as_identifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitKeyword_as_identifier(s) + } +} + +func (s *Keyword_as_identifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitKeyword_as_identifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Keyword_as_identifier() (localctx IKeyword_as_identifierContext) { + localctx = NewKeyword_as_identifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1202, GoogleSQLParserRULE_keyword_as_identifier) + p.SetState(6891) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case GoogleSQLParserINCLUDE_SYMBOL, GoogleSQLParserOFFSET_SYMBOL, GoogleSQLParserOPTIONS_SYMBOL, GoogleSQLParserPERCENT_SYMBOL, GoogleSQLParserPIVOT_SYMBOL, GoogleSQLParserREPLACE_SYMBOL, GoogleSQLParserUNPIVOT_SYMBOL, GoogleSQLParserSYSTEM_SYMBOL, GoogleSQLParserSYSTEM_TIME_SYMBOL, GoogleSQLParserVALUE_SYMBOL, GoogleSQLParserNUMERIC_SYMBOL, GoogleSQLParserDECIMAL_SYMBOL, GoogleSQLParserBIGNUMERIC_SYMBOL, GoogleSQLParserBIGDECIMAL_SYMBOL, GoogleSQLParserJSON_SYMBOL, GoogleSQLParserDATE_SYMBOL, GoogleSQLParserTIME_SYMBOL, GoogleSQLParserDATETIME_SYMBOL, GoogleSQLParserTIMESTAMP_SYMBOL, GoogleSQLParserABORT_SYMBOL, GoogleSQLParserACCESS_SYMBOL, GoogleSQLParserACTION_SYMBOL, GoogleSQLParserAGGREGATE_SYMBOL, GoogleSQLParserADD_SYMBOL, GoogleSQLParserALTER_SYMBOL, GoogleSQLParserALWAYS_SYMBOL, GoogleSQLParserANALYZE_SYMBOL, GoogleSQLParserAPPROX_SYMBOL, GoogleSQLParserARE_SYMBOL, GoogleSQLParserASSERT_SYMBOL, GoogleSQLParserBATCH_SYMBOL, GoogleSQLParserBEGIN_SYMBOL, GoogleSQLParserBREAK_SYMBOL, GoogleSQLParserCALL_SYMBOL, GoogleSQLParserCASCADE_SYMBOL, GoogleSQLParserCHECK_SYMBOL, GoogleSQLParserCLAMPED_SYMBOL, GoogleSQLParserCLONE_SYMBOL, GoogleSQLParserCOPY_SYMBOL, GoogleSQLParserCLUSTER_SYMBOL, GoogleSQLParserCOLUMN_SYMBOL, GoogleSQLParserCOLUMNS_SYMBOL, GoogleSQLParserCOMMIT_SYMBOL, GoogleSQLParserCONNECTION_SYMBOL, GoogleSQLParserCONSTANT_SYMBOL, GoogleSQLParserCONSTRAINT_SYMBOL, GoogleSQLParserCONTINUE_SYMBOL, GoogleSQLParserCORRESPONDING_SYMBOL, GoogleSQLParserCYCLE_SYMBOL, GoogleSQLParserDATA_SYMBOL, GoogleSQLParserDATABASE_SYMBOL, GoogleSQLParserDECLARE_SYMBOL, GoogleSQLParserDEFINER_SYMBOL, GoogleSQLParserDELETE_SYMBOL, GoogleSQLParserDELETION_SYMBOL, GoogleSQLParserDEPTH_SYMBOL, GoogleSQLParserDESCRIBE_SYMBOL, GoogleSQLParserDETERMINISTIC_SYMBOL, GoogleSQLParserDO_SYMBOL, GoogleSQLParserDROP_SYMBOL, GoogleSQLParserELSEIF_SYMBOL, GoogleSQLParserENFORCED_SYMBOL, GoogleSQLParserERROR_SYMBOL, GoogleSQLParserEXCEPTION_SYMBOL, GoogleSQLParserEXECUTE_SYMBOL, GoogleSQLParserEXPLAIN_SYMBOL, GoogleSQLParserEXPORT_SYMBOL, GoogleSQLParserEXTEND_SYMBOL, GoogleSQLParserEXTERNAL_SYMBOL, GoogleSQLParserFILES_SYMBOL, GoogleSQLParserFILTER_SYMBOL, GoogleSQLParserFILL_SYMBOL, GoogleSQLParserFIRST_SYMBOL, GoogleSQLParserFOREIGN_SYMBOL, GoogleSQLParserFORMAT_SYMBOL, GoogleSQLParserFUNCTION_SYMBOL, GoogleSQLParserGENERATED_SYMBOL, GoogleSQLParserGRANT_SYMBOL, GoogleSQLParserGROUP_ROWS_SYMBOL, GoogleSQLParserHIDDEN_SYMBOL, GoogleSQLParserIDENTITY_SYMBOL, GoogleSQLParserIMMEDIATE_SYMBOL, GoogleSQLParserIMMUTABLE_SYMBOL, GoogleSQLParserIMPORT_SYMBOL, GoogleSQLParserINCREMENT_SYMBOL, GoogleSQLParserINDEX_SYMBOL, GoogleSQLParserINOUT_SYMBOL, GoogleSQLParserINPUT_SYMBOL, GoogleSQLParserINSERT_SYMBOL, GoogleSQLParserINVOKER_SYMBOL, GoogleSQLParserISOLATION_SYMBOL, GoogleSQLParserITERATE_SYMBOL, GoogleSQLParserKEY_SYMBOL, GoogleSQLParserLANGUAGE_SYMBOL, GoogleSQLParserLAST_SYMBOL, GoogleSQLParserLEAVE_SYMBOL, GoogleSQLParserLEVEL_SYMBOL, GoogleSQLParserLOAD_SYMBOL, GoogleSQLParserLOOP_SYMBOL, GoogleSQLParserMACRO_SYMBOL, GoogleSQLParserMAP_SYMBOL, GoogleSQLParserMATCH_SYMBOL, GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, GoogleSQLParserMATCHED_SYMBOL, GoogleSQLParserMATERIALIZED_SYMBOL, GoogleSQLParserMAX_SYMBOL, GoogleSQLParserMAXVALUE_SYMBOL, GoogleSQLParserMEASURES_SYMBOL, GoogleSQLParserMESSAGE_SYMBOL, GoogleSQLParserMETADATA_SYMBOL, GoogleSQLParserMIN_SYMBOL, GoogleSQLParserMINVALUE_SYMBOL, GoogleSQLParserMODEL_SYMBOL, GoogleSQLParserMODULE_SYMBOL, GoogleSQLParserONLY_SYMBOL, GoogleSQLParserOUT_SYMBOL, GoogleSQLParserOUTPUT_SYMBOL, GoogleSQLParserOVERWRITE_SYMBOL, GoogleSQLParserPARTITIONS_SYMBOL, GoogleSQLParserPATTERN_SYMBOL, GoogleSQLParserPOLICIES_SYMBOL, GoogleSQLParserPOLICY_SYMBOL, GoogleSQLParserPRIMARY_SYMBOL, GoogleSQLParserPRIVATE_SYMBOL, GoogleSQLParserPRIVILEGE_SYMBOL, GoogleSQLParserPRIVILEGES_SYMBOL, GoogleSQLParserPROCEDURE_SYMBOL, GoogleSQLParserPROJECT_SYMBOL, GoogleSQLParserPUBLIC_SYMBOL, GoogleSQLParserRAISE_SYMBOL, GoogleSQLParserREAD_SYMBOL, GoogleSQLParserREFERENCES_SYMBOL, GoogleSQLParserREMOTE_SYMBOL, GoogleSQLParserREMOVE_SYMBOL, GoogleSQLParserRENAME_SYMBOL, GoogleSQLParserREPEAT_SYMBOL, GoogleSQLParserREPEATABLE_SYMBOL, GoogleSQLParserREPLACE_FIELDS_SYMBOL, GoogleSQLParserREPLICA_SYMBOL, GoogleSQLParserREPORT_SYMBOL, GoogleSQLParserRESTRICT_SYMBOL, GoogleSQLParserRESTRICTION_SYMBOL, GoogleSQLParserRETURNS_SYMBOL, GoogleSQLParserRETURN_SYMBOL, GoogleSQLParserREVOKE_SYMBOL, GoogleSQLParserROLLBACK_SYMBOL, GoogleSQLParserROW_SYMBOL, GoogleSQLParserRUN_SYMBOL, GoogleSQLParserSAFE_CAST_SYMBOL, GoogleSQLParserSCHEMA_SYMBOL, GoogleSQLParserSEARCH_SYMBOL, GoogleSQLParserSECURITY_SYMBOL, GoogleSQLParserSEQUENCE_SYMBOL, GoogleSQLParserSETS_SYMBOL, GoogleSQLParserSHOW_SYMBOL, GoogleSQLParserSNAPSHOT_SYMBOL, GoogleSQLParserSOURCE_SYMBOL, GoogleSQLParserSQL_SYMBOL, GoogleSQLParserSTABLE_SYMBOL, GoogleSQLParserSTART_SYMBOL, GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, GoogleSQLParserSTORED_SYMBOL, GoogleSQLParserSTORING_SYMBOL, GoogleSQLParserSTRICT_SYMBOL, GoogleSQLParserTABLE_SYMBOL, GoogleSQLParserTABLES_SYMBOL, GoogleSQLParserTARGET_SYMBOL, GoogleSQLParserTEMP_SYMBOL, GoogleSQLParserTEMPORARY_SYMBOL, GoogleSQLParserTRANSACTION_SYMBOL, GoogleSQLParserTRANSFORM_SYMBOL, GoogleSQLParserTRUNCATE_SYMBOL, GoogleSQLParserTYPE_SYMBOL, GoogleSQLParserUNDROP_SYMBOL, GoogleSQLParserUNIQUE_SYMBOL, GoogleSQLParserUNKNOWN_SYMBOL, GoogleSQLParserUNTIL_SYMBOL, GoogleSQLParserUPDATE_SYMBOL, GoogleSQLParserVALUES_SYMBOL, GoogleSQLParserVECTOR_SYMBOL, GoogleSQLParserVIEW_SYMBOL, GoogleSQLParserVIEWS_SYMBOL, GoogleSQLParserVOLATILE_SYMBOL, GoogleSQLParserWEIGHT_SYMBOL, GoogleSQLParserWHILE_SYMBOL, GoogleSQLParserWRITE_SYMBOL, GoogleSQLParserZONE_SYMBOL, GoogleSQLParserDESCRIPTOR_SYMBOL, GoogleSQLParserINTERLEAVE_SYMBOL, GoogleSQLParserNULL_FILTERED_SYMBOL, GoogleSQLParserPARENT_SYMBOL, GoogleSQLParserCONFLICT_SYMBOL, GoogleSQLParserDESTINATION_SYMBOL, GoogleSQLParserPROPERTY_SYMBOL, GoogleSQLParserGRAPH_SYMBOL, GoogleSQLParserNODE_SYMBOL, GoogleSQLParserPROPERTIES_SYMBOL, GoogleSQLParserLABEL_SYMBOL, GoogleSQLParserEDGE_SYMBOL, GoogleSQLParserNEXT_SYMBOL, GoogleSQLParserASCENDING_SYMBOL, GoogleSQLParserDESCENDING_SYMBOL, GoogleSQLParserSKIP_SYMBOL, GoogleSQLParserPATH_SYMBOL, GoogleSQLParserPATHS_SYMBOL, GoogleSQLParserWALK_SYMBOL, GoogleSQLParserTRAIL_SYMBOL, GoogleSQLParserACYCLIC_SYMBOL, GoogleSQLParserOPTIONAL_SYMBOL, GoogleSQLParserLET_SYMBOL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6889) + p.Common_keyword_as_identifier() + } + + case GoogleSQLParserSIMPLE_SYMBOL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6890) + p.Match(GoogleSQLParserSIMPLE_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICommon_keyword_as_identifierContext is an interface to support dynamic dispatch. +type ICommon_keyword_as_identifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ABORT_SYMBOL() antlr.TerminalNode + ACCESS_SYMBOL() antlr.TerminalNode + ACTION_SYMBOL() antlr.TerminalNode + AGGREGATE_SYMBOL() antlr.TerminalNode + ADD_SYMBOL() antlr.TerminalNode + ALTER_SYMBOL() antlr.TerminalNode + ALWAYS_SYMBOL() antlr.TerminalNode + ANALYZE_SYMBOL() antlr.TerminalNode + APPROX_SYMBOL() antlr.TerminalNode + ARE_SYMBOL() antlr.TerminalNode + ASSERT_SYMBOL() antlr.TerminalNode + BATCH_SYMBOL() antlr.TerminalNode + BEGIN_SYMBOL() antlr.TerminalNode + BIGDECIMAL_SYMBOL() antlr.TerminalNode + BIGNUMERIC_SYMBOL() antlr.TerminalNode + BREAK_SYMBOL() antlr.TerminalNode + CALL_SYMBOL() antlr.TerminalNode + CASCADE_SYMBOL() antlr.TerminalNode + CHECK_SYMBOL() antlr.TerminalNode + CLAMPED_SYMBOL() antlr.TerminalNode + CONFLICT_SYMBOL() antlr.TerminalNode + CLONE_SYMBOL() antlr.TerminalNode + COPY_SYMBOL() antlr.TerminalNode + CLUSTER_SYMBOL() antlr.TerminalNode + COLUMN_SYMBOL() antlr.TerminalNode + COLUMNS_SYMBOL() antlr.TerminalNode + COMMIT_SYMBOL() antlr.TerminalNode + CONNECTION_SYMBOL() antlr.TerminalNode + CONSTANT_SYMBOL() antlr.TerminalNode + CONSTRAINT_SYMBOL() antlr.TerminalNode + CONTINUE_SYMBOL() antlr.TerminalNode + CORRESPONDING_SYMBOL() antlr.TerminalNode + CYCLE_SYMBOL() antlr.TerminalNode + DATA_SYMBOL() antlr.TerminalNode + DATABASE_SYMBOL() antlr.TerminalNode + DATE_SYMBOL() antlr.TerminalNode + DATETIME_SYMBOL() antlr.TerminalNode + DECIMAL_SYMBOL() antlr.TerminalNode + DECLARE_SYMBOL() antlr.TerminalNode + DEFINER_SYMBOL() antlr.TerminalNode + DELETE_SYMBOL() antlr.TerminalNode + DELETION_SYMBOL() antlr.TerminalNode + DEPTH_SYMBOL() antlr.TerminalNode + DESCRIBE_SYMBOL() antlr.TerminalNode + DETERMINISTIC_SYMBOL() antlr.TerminalNode + DO_SYMBOL() antlr.TerminalNode + DROP_SYMBOL() antlr.TerminalNode + ELSEIF_SYMBOL() antlr.TerminalNode + ENFORCED_SYMBOL() antlr.TerminalNode + ERROR_SYMBOL() antlr.TerminalNode + EXCEPTION_SYMBOL() antlr.TerminalNode + EXECUTE_SYMBOL() antlr.TerminalNode + EXPLAIN_SYMBOL() antlr.TerminalNode + EXPORT_SYMBOL() antlr.TerminalNode + EXTEND_SYMBOL() antlr.TerminalNode + EXTERNAL_SYMBOL() antlr.TerminalNode + FILES_SYMBOL() antlr.TerminalNode + FILTER_SYMBOL() antlr.TerminalNode + FILL_SYMBOL() antlr.TerminalNode + FIRST_SYMBOL() antlr.TerminalNode + FOREIGN_SYMBOL() antlr.TerminalNode + FORMAT_SYMBOL() antlr.TerminalNode + FUNCTION_SYMBOL() antlr.TerminalNode + GENERATED_SYMBOL() antlr.TerminalNode + GRANT_SYMBOL() antlr.TerminalNode + GROUP_ROWS_SYMBOL() antlr.TerminalNode + HIDDEN_SYMBOL() antlr.TerminalNode + IDENTITY_SYMBOL() antlr.TerminalNode + IMMEDIATE_SYMBOL() antlr.TerminalNode + IMMUTABLE_SYMBOL() antlr.TerminalNode + IMPORT_SYMBOL() antlr.TerminalNode + INCLUDE_SYMBOL() antlr.TerminalNode + INCREMENT_SYMBOL() antlr.TerminalNode + INDEX_SYMBOL() antlr.TerminalNode + INOUT_SYMBOL() antlr.TerminalNode + INPUT_SYMBOL() antlr.TerminalNode + INSERT_SYMBOL() antlr.TerminalNode + INVOKER_SYMBOL() antlr.TerminalNode + ISOLATION_SYMBOL() antlr.TerminalNode + ITERATE_SYMBOL() antlr.TerminalNode + JSON_SYMBOL() antlr.TerminalNode + KEY_SYMBOL() antlr.TerminalNode + LANGUAGE_SYMBOL() antlr.TerminalNode + LAST_SYMBOL() antlr.TerminalNode + LEAVE_SYMBOL() antlr.TerminalNode + LEVEL_SYMBOL() antlr.TerminalNode + LOAD_SYMBOL() antlr.TerminalNode + LOOP_SYMBOL() antlr.TerminalNode + MACRO_SYMBOL() antlr.TerminalNode + MAP_SYMBOL() antlr.TerminalNode + MATCH_SYMBOL() antlr.TerminalNode + KW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL() antlr.TerminalNode + MATCHED_SYMBOL() antlr.TerminalNode + MATERIALIZED_SYMBOL() antlr.TerminalNode + MAX_SYMBOL() antlr.TerminalNode + MAXVALUE_SYMBOL() antlr.TerminalNode + MEASURES_SYMBOL() antlr.TerminalNode + MESSAGE_SYMBOL() antlr.TerminalNode + METADATA_SYMBOL() antlr.TerminalNode + MIN_SYMBOL() antlr.TerminalNode + MINVALUE_SYMBOL() antlr.TerminalNode + MODEL_SYMBOL() antlr.TerminalNode + MODULE_SYMBOL() antlr.TerminalNode + NUMERIC_SYMBOL() antlr.TerminalNode + OFFSET_SYMBOL() antlr.TerminalNode + ONLY_SYMBOL() antlr.TerminalNode + OPTIONS_SYMBOL() antlr.TerminalNode + OUT_SYMBOL() antlr.TerminalNode + OUTPUT_SYMBOL() antlr.TerminalNode + OVERWRITE_SYMBOL() antlr.TerminalNode + PARTITIONS_SYMBOL() antlr.TerminalNode + PATTERN_SYMBOL() antlr.TerminalNode + PERCENT_SYMBOL() antlr.TerminalNode + PIVOT_SYMBOL() antlr.TerminalNode + POLICIES_SYMBOL() antlr.TerminalNode + POLICY_SYMBOL() antlr.TerminalNode + PRIMARY_SYMBOL() antlr.TerminalNode + PRIVATE_SYMBOL() antlr.TerminalNode + PRIVILEGE_SYMBOL() antlr.TerminalNode + PRIVILEGES_SYMBOL() antlr.TerminalNode + PROCEDURE_SYMBOL() antlr.TerminalNode + PROJECT_SYMBOL() antlr.TerminalNode + PUBLIC_SYMBOL() antlr.TerminalNode + RAISE_SYMBOL() antlr.TerminalNode + READ_SYMBOL() antlr.TerminalNode + REFERENCES_SYMBOL() antlr.TerminalNode + REMOTE_SYMBOL() antlr.TerminalNode + REMOVE_SYMBOL() antlr.TerminalNode + RENAME_SYMBOL() antlr.TerminalNode + REPEAT_SYMBOL() antlr.TerminalNode + REPEATABLE_SYMBOL() antlr.TerminalNode + REPLACE_SYMBOL() antlr.TerminalNode + REPLACE_FIELDS_SYMBOL() antlr.TerminalNode + REPLICA_SYMBOL() antlr.TerminalNode + REPORT_SYMBOL() antlr.TerminalNode + RESTRICT_SYMBOL() antlr.TerminalNode + RESTRICTION_SYMBOL() antlr.TerminalNode + RETURNS_SYMBOL() antlr.TerminalNode + RETURN_SYMBOL() antlr.TerminalNode + REVOKE_SYMBOL() antlr.TerminalNode + ROLLBACK_SYMBOL() antlr.TerminalNode + ROW_SYMBOL() antlr.TerminalNode + RUN_SYMBOL() antlr.TerminalNode + SAFE_CAST_SYMBOL() antlr.TerminalNode + SCHEMA_SYMBOL() antlr.TerminalNode + SEARCH_SYMBOL() antlr.TerminalNode + SECURITY_SYMBOL() antlr.TerminalNode + SEQUENCE_SYMBOL() antlr.TerminalNode + SETS_SYMBOL() antlr.TerminalNode + SHOW_SYMBOL() antlr.TerminalNode + SNAPSHOT_SYMBOL() antlr.TerminalNode + SOURCE_SYMBOL() antlr.TerminalNode + SQL_SYMBOL() antlr.TerminalNode + STABLE_SYMBOL() antlr.TerminalNode + START_SYMBOL() antlr.TerminalNode + STATIC_DESCRIBE_SYMBOL() antlr.TerminalNode + STORED_SYMBOL() antlr.TerminalNode + STORING_SYMBOL() antlr.TerminalNode + STRICT_SYMBOL() antlr.TerminalNode + SYSTEM_SYMBOL() antlr.TerminalNode + SYSTEM_TIME_SYMBOL() antlr.TerminalNode + TABLE_SYMBOL() antlr.TerminalNode + TABLES_SYMBOL() antlr.TerminalNode + TARGET_SYMBOL() antlr.TerminalNode + TEMP_SYMBOL() antlr.TerminalNode + TEMPORARY_SYMBOL() antlr.TerminalNode + TIME_SYMBOL() antlr.TerminalNode + TIMESTAMP_SYMBOL() antlr.TerminalNode + TRANSACTION_SYMBOL() antlr.TerminalNode + TRANSFORM_SYMBOL() antlr.TerminalNode + TRUNCATE_SYMBOL() antlr.TerminalNode + TYPE_SYMBOL() antlr.TerminalNode + UNDROP_SYMBOL() antlr.TerminalNode + UNIQUE_SYMBOL() antlr.TerminalNode + UNKNOWN_SYMBOL() antlr.TerminalNode + UNPIVOT_SYMBOL() antlr.TerminalNode + UNTIL_SYMBOL() antlr.TerminalNode + UPDATE_SYMBOL() antlr.TerminalNode + VALUE_SYMBOL() antlr.TerminalNode + VALUES_SYMBOL() antlr.TerminalNode + VECTOR_SYMBOL() antlr.TerminalNode + VIEW_SYMBOL() antlr.TerminalNode + VIEWS_SYMBOL() antlr.TerminalNode + VOLATILE_SYMBOL() antlr.TerminalNode + WEIGHT_SYMBOL() antlr.TerminalNode + WHILE_SYMBOL() antlr.TerminalNode + WRITE_SYMBOL() antlr.TerminalNode + ZONE_SYMBOL() antlr.TerminalNode + DESCRIPTOR_SYMBOL() antlr.TerminalNode + INTERLEAVE_SYMBOL() antlr.TerminalNode + NULL_FILTERED_SYMBOL() antlr.TerminalNode + PARENT_SYMBOL() antlr.TerminalNode + DESTINATION_SYMBOL() antlr.TerminalNode + PROPERTY_SYMBOL() antlr.TerminalNode + GRAPH_SYMBOL() antlr.TerminalNode + NODE_SYMBOL() antlr.TerminalNode + PROPERTIES_SYMBOL() antlr.TerminalNode + LABEL_SYMBOL() antlr.TerminalNode + EDGE_SYMBOL() antlr.TerminalNode + NEXT_SYMBOL() antlr.TerminalNode + ASCENDING_SYMBOL() antlr.TerminalNode + DESCENDING_SYMBOL() antlr.TerminalNode + SKIP_SYMBOL() antlr.TerminalNode + PATH_SYMBOL() antlr.TerminalNode + PATHS_SYMBOL() antlr.TerminalNode + WALK_SYMBOL() antlr.TerminalNode + TRAIL_SYMBOL() antlr.TerminalNode + ACYCLIC_SYMBOL() antlr.TerminalNode + OPTIONAL_SYMBOL() antlr.TerminalNode + LET_SYMBOL() antlr.TerminalNode + + // IsCommon_keyword_as_identifierContext differentiates from other interfaces. + IsCommon_keyword_as_identifierContext() +} + +type Common_keyword_as_identifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCommon_keyword_as_identifierContext() *Common_keyword_as_identifierContext { + var p = new(Common_keyword_as_identifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_common_keyword_as_identifier + return p +} + +func InitEmptyCommon_keyword_as_identifierContext(p *Common_keyword_as_identifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_common_keyword_as_identifier +} + +func (*Common_keyword_as_identifierContext) IsCommon_keyword_as_identifierContext() {} + +func NewCommon_keyword_as_identifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Common_keyword_as_identifierContext { + var p = new(Common_keyword_as_identifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_common_keyword_as_identifier + + return p +} + +func (s *Common_keyword_as_identifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *Common_keyword_as_identifierContext) ABORT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserABORT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) ACCESS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserACCESS_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) ACTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserACTION_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) AGGREGATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAGGREGATE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) ADD_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserADD_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) ALTER_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserALTER_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) ALWAYS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserALWAYS_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) ANALYZE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserANALYZE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) APPROX_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserAPPROX_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) ARE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserARE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) ASSERT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserASSERT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) BATCH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBATCH_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) BEGIN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBEGIN_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) BIGDECIMAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBIGDECIMAL_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) BIGNUMERIC_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBIGNUMERIC_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) BREAK_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBREAK_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) CALL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCALL_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) CASCADE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCASCADE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) CHECK_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCHECK_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) CLAMPED_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCLAMPED_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) CONFLICT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCONFLICT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) CLONE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCLONE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) COPY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOPY_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) CLUSTER_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCLUSTER_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) COLUMN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOLUMN_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) COLUMNS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOLUMNS_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) COMMIT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMIT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) CONNECTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCONNECTION_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) CONSTANT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCONSTANT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) CONSTRAINT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCONSTRAINT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) CONTINUE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCONTINUE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) CORRESPONDING_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCORRESPONDING_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) CYCLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCYCLE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) DATA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDATA_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) DATABASE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDATABASE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) DATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDATE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) DATETIME_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDATETIME_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) DECIMAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDECIMAL_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) DECLARE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDECLARE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) DEFINER_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDEFINER_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) DELETE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDELETE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) DELETION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDELETION_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) DEPTH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDEPTH_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) DESCRIBE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDESCRIBE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) DETERMINISTIC_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDETERMINISTIC_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) DO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDO_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) DROP_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDROP_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) ELSEIF_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserELSEIF_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) ENFORCED_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserENFORCED_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) ERROR_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserERROR_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) EXCEPTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXCEPTION_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) EXECUTE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXECUTE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) EXPLAIN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXPLAIN_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) EXPORT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXPORT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) EXTEND_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXTEND_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) EXTERNAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEXTERNAL_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) FILES_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFILES_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) FILTER_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFILTER_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) FILL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFILL_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) FIRST_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFIRST_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) FOREIGN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFOREIGN_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) FORMAT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFORMAT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) FUNCTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFUNCTION_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) GENERATED_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserGENERATED_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) GRANT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserGRANT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) GROUP_ROWS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserGROUP_ROWS_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) HIDDEN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserHIDDEN_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) IDENTITY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIDENTITY_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) IMMEDIATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIMMEDIATE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) IMMUTABLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIMMUTABLE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) IMPORT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIMPORT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) INCLUDE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINCLUDE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) INCREMENT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINCREMENT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) INDEX_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINDEX_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) INOUT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINOUT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) INPUT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINPUT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) INSERT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINSERT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) INVOKER_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINVOKER_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) ISOLATION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserISOLATION_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) ITERATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserITERATE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) JSON_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserJSON_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) KEY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserKEY_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) LANGUAGE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLANGUAGE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) LAST_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLAST_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) LEAVE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLEAVE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) LEVEL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLEVEL_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) LOAD_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLOAD_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) LOOP_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLOOP_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) MACRO_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMACRO_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) MAP_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMAP_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) MATCH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMATCH_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) KW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserKW_MATCH_RECOGNIZE_NONRESERVED_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) MATCHED_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMATCHED_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) MATERIALIZED_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMATERIALIZED_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) MAX_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMAX_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) MAXVALUE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMAXVALUE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) MEASURES_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMEASURES_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) MESSAGE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMESSAGE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) METADATA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMETADATA_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) MIN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMIN_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) MINVALUE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMINVALUE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) MODEL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMODEL_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) MODULE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserMODULE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) NUMERIC_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNUMERIC_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) OFFSET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOFFSET_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) ONLY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserONLY_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) OPTIONS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOPTIONS_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) OUT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOUT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) OUTPUT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOUTPUT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) OVERWRITE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOVERWRITE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) PARTITIONS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPARTITIONS_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) PATTERN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPATTERN_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) PERCENT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPERCENT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) PIVOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPIVOT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) POLICIES_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPOLICIES_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) POLICY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPOLICY_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) PRIMARY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPRIMARY_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) PRIVATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPRIVATE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) PRIVILEGE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPRIVILEGE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) PRIVILEGES_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPRIVILEGES_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) PROCEDURE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPROCEDURE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) PROJECT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPROJECT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) PUBLIC_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPUBLIC_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) RAISE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRAISE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) READ_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREAD_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) REFERENCES_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREFERENCES_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) REMOTE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREMOTE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) REMOVE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREMOVE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) RENAME_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRENAME_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) REPEAT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREPEAT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) REPEATABLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREPEATABLE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) REPLACE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREPLACE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) REPLACE_FIELDS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREPLACE_FIELDS_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) REPLICA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREPLICA_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) REPORT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREPORT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) RESTRICT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRESTRICT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) RESTRICTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRESTRICTION_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) RETURNS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRETURNS_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) RETURN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRETURN_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) REVOKE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserREVOKE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) ROLLBACK_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserROLLBACK_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) ROW_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserROW_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) RUN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserRUN_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) SAFE_CAST_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSAFE_CAST_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) SCHEMA_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSCHEMA_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) SEARCH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSEARCH_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) SECURITY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSECURITY_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) SEQUENCE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSEQUENCE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) SETS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSETS_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) SHOW_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSHOW_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) SNAPSHOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSNAPSHOT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) SOURCE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSOURCE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) SQL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSQL_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) STABLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTABLE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) START_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTART_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) STATIC_DESCRIBE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTATIC_DESCRIBE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) STORED_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTORED_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) STORING_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTORING_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) STRICT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTRICT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) SYSTEM_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSYSTEM_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) SYSTEM_TIME_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSYSTEM_TIME_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) TABLE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTABLE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) TABLES_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTABLES_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) TARGET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTARGET_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) TEMP_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTEMP_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) TEMPORARY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTEMPORARY_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) TIME_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTIME_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) TIMESTAMP_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTIMESTAMP_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) TRANSACTION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTRANSACTION_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) TRANSFORM_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTRANSFORM_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) TRUNCATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTRUNCATE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) TYPE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTYPE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) UNDROP_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUNDROP_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) UNIQUE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUNIQUE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) UNKNOWN_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUNKNOWN_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) UNPIVOT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUNPIVOT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) UNTIL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUNTIL_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) UPDATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserUPDATE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) VALUE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserVALUE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) VALUES_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserVALUES_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) VECTOR_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserVECTOR_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) VIEW_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserVIEW_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) VIEWS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserVIEWS_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) VOLATILE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserVOLATILE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) WEIGHT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWEIGHT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) WHILE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWHILE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) WRITE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWRITE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) ZONE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserZONE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) DESCRIPTOR_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDESCRIPTOR_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) INTERLEAVE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINTERLEAVE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) NULL_FILTERED_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNULL_FILTERED_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) PARENT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPARENT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) DESTINATION_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDESTINATION_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) PROPERTY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPROPERTY_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) GRAPH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserGRAPH_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) NODE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNODE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) PROPERTIES_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPROPERTIES_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) LABEL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLABEL_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) EDGE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserEDGE_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) NEXT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNEXT_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) ASCENDING_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserASCENDING_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) DESCENDING_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDESCENDING_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) SKIP_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSKIP_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) PATH_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPATH_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) PATHS_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserPATHS_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) WALK_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserWALK_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) TRAIL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTRAIL_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) ACYCLIC_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserACYCLIC_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) OPTIONAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserOPTIONAL_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) LET_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLET_SYMBOL, 0) +} + +func (s *Common_keyword_as_identifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Common_keyword_as_identifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Common_keyword_as_identifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterCommon_keyword_as_identifier(s) + } +} + +func (s *Common_keyword_as_identifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitCommon_keyword_as_identifier(s) + } +} + +func (s *Common_keyword_as_identifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitCommon_keyword_as_identifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Common_keyword_as_identifier() (localctx ICommon_keyword_as_identifierContext) { + localctx = NewCommon_keyword_as_identifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1204, GoogleSQLParserRULE_common_keyword_as_identifier) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6893) + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-74)) & ^0x3f) == 0 && ((int64(1)<<(_la-74))&-247260703569407) != 0) || ((int64((_la-138)) & ^0x3f) == 0 && ((int64(1)<<(_la-138))&-1) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-36028797018963969) != 0) || ((int64((_la-266)) & ^0x3f) == 0 && ((int64(1)<<(_la-266))&536870911) != 0) || ((int64((_la-340)) & ^0x3f) == 0 && ((int64(1)<<(_la-340))&16711649) != 0)) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IToken_identifierContext is an interface to support dynamic dispatch. +type IToken_identifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IDENTIFIER() antlr.TerminalNode + + // IsToken_identifierContext differentiates from other interfaces. + IsToken_identifierContext() +} + +type Token_identifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyToken_identifierContext() *Token_identifierContext { + var p = new(Token_identifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_token_identifier + return p +} + +func InitEmptyToken_identifierContext(p *Token_identifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_token_identifier +} + +func (*Token_identifierContext) IsToken_identifierContext() {} + +func NewToken_identifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Token_identifierContext { + var p = new(Token_identifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_token_identifier + + return p +} + +func (s *Token_identifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *Token_identifierContext) IDENTIFIER() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserIDENTIFIER, 0) +} + +func (s *Token_identifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Token_identifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Token_identifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterToken_identifier(s) + } +} + +func (s *Token_identifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitToken_identifier(s) + } +} + +func (s *Token_identifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitToken_identifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Token_identifier() (localctx IToken_identifierContext) { + localctx = NewToken_identifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1206, GoogleSQLParserRULE_token_identifier) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6895) + p.Match(GoogleSQLParserIDENTIFIER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStruct_typeContext is an interface to support dynamic dispatch. +type IStruct_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STRUCT_SYMBOL() antlr.TerminalNode + Template_type_open() ITemplate_type_openContext + Template_type_close() ITemplate_type_closeContext + Struct_type_prefix() IStruct_type_prefixContext + + // IsStruct_typeContext differentiates from other interfaces. + IsStruct_typeContext() +} + +type Struct_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStruct_typeContext() *Struct_typeContext { + var p = new(Struct_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_struct_type + return p +} + +func InitEmptyStruct_typeContext(p *Struct_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_struct_type +} + +func (*Struct_typeContext) IsStruct_typeContext() {} + +func NewStruct_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Struct_typeContext { + var p = new(Struct_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_struct_type + + return p +} + +func (s *Struct_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Struct_typeContext) STRUCT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTRUCT_SYMBOL, 0) +} + +func (s *Struct_typeContext) Template_type_open() ITemplate_type_openContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemplate_type_openContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemplate_type_openContext) +} + +func (s *Struct_typeContext) Template_type_close() ITemplate_type_closeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemplate_type_closeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemplate_type_closeContext) +} + +func (s *Struct_typeContext) Struct_type_prefix() IStruct_type_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStruct_type_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStruct_type_prefixContext) +} + +func (s *Struct_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Struct_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Struct_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterStruct_type(s) + } +} + +func (s *Struct_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitStruct_type(s) + } +} + +func (s *Struct_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitStruct_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Struct_type() (localctx IStruct_typeContext) { + localctx = NewStruct_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1208, GoogleSQLParserRULE_struct_type) + p.SetState(6904) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 843, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6897) + p.Match(GoogleSQLParserSTRUCT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6898) + p.Template_type_open() + } + { + p.SetState(6899) + p.Template_type_close() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6901) + p.Struct_type_prefix() + } + { + p.SetState(6902) + p.Template_type_close() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStruct_type_prefixContext is an interface to support dynamic dispatch. +type IStruct_type_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STRUCT_SYMBOL() antlr.TerminalNode + Template_type_open() ITemplate_type_openContext + AllStruct_field() []IStruct_fieldContext + Struct_field(i int) IStruct_fieldContext + AllCOMMA_SYMBOL() []antlr.TerminalNode + COMMA_SYMBOL(i int) antlr.TerminalNode + + // IsStruct_type_prefixContext differentiates from other interfaces. + IsStruct_type_prefixContext() +} + +type Struct_type_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStruct_type_prefixContext() *Struct_type_prefixContext { + var p = new(Struct_type_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_struct_type_prefix + return p +} + +func InitEmptyStruct_type_prefixContext(p *Struct_type_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_struct_type_prefix +} + +func (*Struct_type_prefixContext) IsStruct_type_prefixContext() {} + +func NewStruct_type_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Struct_type_prefixContext { + var p = new(Struct_type_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_struct_type_prefix + + return p +} + +func (s *Struct_type_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Struct_type_prefixContext) STRUCT_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTRUCT_SYMBOL, 0) +} + +func (s *Struct_type_prefixContext) Template_type_open() ITemplate_type_openContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemplate_type_openContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemplate_type_openContext) +} + +func (s *Struct_type_prefixContext) AllStruct_field() []IStruct_fieldContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStruct_fieldContext); ok { + len++ + } + } + + tst := make([]IStruct_fieldContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStruct_fieldContext); ok { + tst[i] = t.(IStruct_fieldContext) + i++ + } + } + + return tst +} + +func (s *Struct_type_prefixContext) Struct_field(i int) IStruct_fieldContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStruct_fieldContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStruct_fieldContext) +} + +func (s *Struct_type_prefixContext) AllCOMMA_SYMBOL() []antlr.TerminalNode { + return s.GetTokens(GoogleSQLParserCOMMA_SYMBOL) +} + +func (s *Struct_type_prefixContext) COMMA_SYMBOL(i int) antlr.TerminalNode { + return s.GetToken(GoogleSQLParserCOMMA_SYMBOL, i) +} + +func (s *Struct_type_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Struct_type_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Struct_type_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterStruct_type_prefix(s) + } +} + +func (s *Struct_type_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitStruct_type_prefix(s) + } +} + +func (s *Struct_type_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitStruct_type_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Struct_type_prefix() (localctx IStruct_type_prefixContext) { + localctx = NewStruct_type_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1210, GoogleSQLParserRULE_struct_type_prefix) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6906) + p.Match(GoogleSQLParserSTRUCT_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6907) + p.Template_type_open() + } + { + p.SetState(6908) + p.Struct_field() + } + p.SetState(6913) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == GoogleSQLParserCOMMA_SYMBOL { + { + p.SetState(6909) + p.Match(GoogleSQLParserCOMMA_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6910) + p.Struct_field() + } + + p.SetState(6915) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStruct_fieldContext is an interface to support dynamic dispatch. +type IStruct_fieldContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Type_() ITypeContext + + // IsStruct_fieldContext differentiates from other interfaces. + IsStruct_fieldContext() +} + +type Struct_fieldContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStruct_fieldContext() *Struct_fieldContext { + var p = new(Struct_fieldContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_struct_field + return p +} + +func InitEmptyStruct_fieldContext(p *Struct_fieldContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_struct_field +} + +func (*Struct_fieldContext) IsStruct_fieldContext() {} + +func NewStruct_fieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Struct_fieldContext { + var p = new(Struct_fieldContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_struct_field + + return p +} + +func (s *Struct_fieldContext) GetParser() antlr.Parser { return s.parser } + +func (s *Struct_fieldContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Struct_fieldContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *Struct_fieldContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Struct_fieldContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Struct_fieldContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterStruct_field(s) + } +} + +func (s *Struct_fieldContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitStruct_field(s) + } +} + +func (s *Struct_fieldContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitStruct_field(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Struct_field() (localctx IStruct_fieldContext) { + localctx = NewStruct_fieldContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1212, GoogleSQLParserRULE_struct_field) + p.SetState(6920) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 845, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6916) + p.Identifier() + } + { + p.SetState(6917) + p.Type_() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6919) + p.Type_() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IArray_typeContext is an interface to support dynamic dispatch. +type IArray_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ARRAY_SYMBOL() antlr.TerminalNode + Template_type_open() ITemplate_type_openContext + Type_() ITypeContext + Template_type_close() ITemplate_type_closeContext + + // IsArray_typeContext differentiates from other interfaces. + IsArray_typeContext() +} + +type Array_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyArray_typeContext() *Array_typeContext { + var p = new(Array_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_array_type + return p +} + +func InitEmptyArray_typeContext(p *Array_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_array_type +} + +func (*Array_typeContext) IsArray_typeContext() {} + +func NewArray_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Array_typeContext { + var p = new(Array_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_array_type + + return p +} + +func (s *Array_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Array_typeContext) ARRAY_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserARRAY_SYMBOL, 0) +} + +func (s *Array_typeContext) Template_type_open() ITemplate_type_openContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemplate_type_openContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemplate_type_openContext) +} + +func (s *Array_typeContext) Type_() ITypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeContext) +} + +func (s *Array_typeContext) Template_type_close() ITemplate_type_closeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemplate_type_closeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemplate_type_closeContext) +} + +func (s *Array_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Array_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Array_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterArray_type(s) + } +} + +func (s *Array_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitArray_type(s) + } +} + +func (s *Array_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitArray_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Array_type() (localctx IArray_typeContext) { + localctx = NewArray_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1214, GoogleSQLParserRULE_array_type) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6922) + p.Match(GoogleSQLParserARRAY_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6923) + p.Template_type_open() + } + { + p.SetState(6924) + p.Type_() + } + { + p.SetState(6925) + p.Template_type_close() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITemplate_type_openContext is an interface to support dynamic dispatch. +type ITemplate_type_openContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LT_OPERATOR() antlr.TerminalNode + + // IsTemplate_type_openContext differentiates from other interfaces. + IsTemplate_type_openContext() +} + +type Template_type_openContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTemplate_type_openContext() *Template_type_openContext { + var p = new(Template_type_openContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_template_type_open + return p +} + +func InitEmptyTemplate_type_openContext(p *Template_type_openContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_template_type_open +} + +func (*Template_type_openContext) IsTemplate_type_openContext() {} + +func NewTemplate_type_openContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Template_type_openContext { + var p = new(Template_type_openContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_template_type_open + + return p +} + +func (s *Template_type_openContext) GetParser() antlr.Parser { return s.parser } + +func (s *Template_type_openContext) LT_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserLT_OPERATOR, 0) +} + +func (s *Template_type_openContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Template_type_openContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Template_type_openContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTemplate_type_open(s) + } +} + +func (s *Template_type_openContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTemplate_type_open(s) + } +} + +func (s *Template_type_openContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTemplate_type_open(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Template_type_open() (localctx ITemplate_type_openContext) { + localctx = NewTemplate_type_openContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1216, GoogleSQLParserRULE_template_type_open) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6927) + p.Match(GoogleSQLParserLT_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITemplate_type_closeContext is an interface to support dynamic dispatch. +type ITemplate_type_closeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GT_OPERATOR() antlr.TerminalNode + + // IsTemplate_type_closeContext differentiates from other interfaces. + IsTemplate_type_closeContext() +} + +type Template_type_closeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTemplate_type_closeContext() *Template_type_closeContext { + var p = new(Template_type_closeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_template_type_close + return p +} + +func InitEmptyTemplate_type_closeContext(p *Template_type_closeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_template_type_close +} + +func (*Template_type_closeContext) IsTemplate_type_closeContext() {} + +func NewTemplate_type_closeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Template_type_closeContext { + var p = new(Template_type_closeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_template_type_close + + return p +} + +func (s *Template_type_closeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Template_type_closeContext) GT_OPERATOR() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserGT_OPERATOR, 0) +} + +func (s *Template_type_closeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Template_type_closeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Template_type_closeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterTemplate_type_close(s) + } +} + +func (s *Template_type_closeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitTemplate_type_close(s) + } +} + +func (s *Template_type_closeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitTemplate_type_close(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Template_type_close() (localctx ITemplate_type_closeContext) { + localctx = NewTemplate_type_closeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1218, GoogleSQLParserRULE_template_type_close) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6929) + p.Match(GoogleSQLParserGT_OPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDate_or_time_literalContext is an interface to support dynamic dispatch. +type IDate_or_time_literalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Date_or_time_literal_kind() IDate_or_time_literal_kindContext + String_literal() IString_literalContext + + // IsDate_or_time_literalContext differentiates from other interfaces. + IsDate_or_time_literalContext() +} + +type Date_or_time_literalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDate_or_time_literalContext() *Date_or_time_literalContext { + var p = new(Date_or_time_literalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_date_or_time_literal + return p +} + +func InitEmptyDate_or_time_literalContext(p *Date_or_time_literalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_date_or_time_literal +} + +func (*Date_or_time_literalContext) IsDate_or_time_literalContext() {} + +func NewDate_or_time_literalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Date_or_time_literalContext { + var p = new(Date_or_time_literalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_date_or_time_literal + + return p +} + +func (s *Date_or_time_literalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Date_or_time_literalContext) Date_or_time_literal_kind() IDate_or_time_literal_kindContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDate_or_time_literal_kindContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDate_or_time_literal_kindContext) +} + +func (s *Date_or_time_literalContext) String_literal() IString_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_literalContext) +} + +func (s *Date_or_time_literalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Date_or_time_literalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Date_or_time_literalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterDate_or_time_literal(s) + } +} + +func (s *Date_or_time_literalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitDate_or_time_literal(s) + } +} + +func (s *Date_or_time_literalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitDate_or_time_literal(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Date_or_time_literal() (localctx IDate_or_time_literalContext) { + localctx = NewDate_or_time_literalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1220, GoogleSQLParserRULE_date_or_time_literal) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6931) + p.Date_or_time_literal_kind() + } + { + p.SetState(6932) + p.string_literal(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDate_or_time_literal_kindContext is an interface to support dynamic dispatch. +type IDate_or_time_literal_kindContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATE_SYMBOL() antlr.TerminalNode + TIME_SYMBOL() antlr.TerminalNode + DATETIME_SYMBOL() antlr.TerminalNode + TIMESTAMP_SYMBOL() antlr.TerminalNode + + // IsDate_or_time_literal_kindContext differentiates from other interfaces. + IsDate_or_time_literal_kindContext() +} + +type Date_or_time_literal_kindContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDate_or_time_literal_kindContext() *Date_or_time_literal_kindContext { + var p = new(Date_or_time_literal_kindContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_date_or_time_literal_kind + return p +} + +func InitEmptyDate_or_time_literal_kindContext(p *Date_or_time_literal_kindContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_date_or_time_literal_kind +} + +func (*Date_or_time_literal_kindContext) IsDate_or_time_literal_kindContext() {} + +func NewDate_or_time_literal_kindContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Date_or_time_literal_kindContext { + var p = new(Date_or_time_literal_kindContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_date_or_time_literal_kind + + return p +} + +func (s *Date_or_time_literal_kindContext) GetParser() antlr.Parser { return s.parser } + +func (s *Date_or_time_literal_kindContext) DATE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDATE_SYMBOL, 0) +} + +func (s *Date_or_time_literal_kindContext) TIME_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTIME_SYMBOL, 0) +} + +func (s *Date_or_time_literal_kindContext) DATETIME_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDATETIME_SYMBOL, 0) +} + +func (s *Date_or_time_literal_kindContext) TIMESTAMP_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTIMESTAMP_SYMBOL, 0) +} + +func (s *Date_or_time_literal_kindContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Date_or_time_literal_kindContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Date_or_time_literal_kindContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterDate_or_time_literal_kind(s) + } +} + +func (s *Date_or_time_literal_kindContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitDate_or_time_literal_kind(s) + } +} + +func (s *Date_or_time_literal_kindContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitDate_or_time_literal_kind(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Date_or_time_literal_kind() (localctx IDate_or_time_literal_kindContext) { + localctx = NewDate_or_time_literal_kindContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1222, GoogleSQLParserRULE_date_or_time_literal_kind) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6934) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-115)) & ^0x3f) == 0 && ((int64(1)<<(_la-115))&15) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFloating_point_literalContext is an interface to support dynamic dispatch. +type IFloating_point_literalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FLOATING_POINT_LITERAL() antlr.TerminalNode + + // IsFloating_point_literalContext differentiates from other interfaces. + IsFloating_point_literalContext() +} + +type Floating_point_literalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFloating_point_literalContext() *Floating_point_literalContext { + var p = new(Floating_point_literalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_floating_point_literal + return p +} + +func InitEmptyFloating_point_literalContext(p *Floating_point_literalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_floating_point_literal +} + +func (*Floating_point_literalContext) IsFloating_point_literalContext() {} + +func NewFloating_point_literalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Floating_point_literalContext { + var p = new(Floating_point_literalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_floating_point_literal + + return p +} + +func (s *Floating_point_literalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Floating_point_literalContext) FLOATING_POINT_LITERAL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFLOATING_POINT_LITERAL, 0) +} + +func (s *Floating_point_literalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Floating_point_literalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Floating_point_literalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterFloating_point_literal(s) + } +} + +func (s *Floating_point_literalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitFloating_point_literal(s) + } +} + +func (s *Floating_point_literalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitFloating_point_literal(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Floating_point_literal() (localctx IFloating_point_literalContext) { + localctx = NewFloating_point_literalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1224, GoogleSQLParserRULE_floating_point_literal) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6936) + p.Match(GoogleSQLParserFLOATING_POINT_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_literalContext is an interface to support dynamic dispatch. +type IJson_literalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + JSON_SYMBOL() antlr.TerminalNode + String_literal() IString_literalContext + + // IsJson_literalContext differentiates from other interfaces. + IsJson_literalContext() +} + +type Json_literalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_literalContext() *Json_literalContext { + var p = new(Json_literalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_json_literal + return p +} + +func InitEmptyJson_literalContext(p *Json_literalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_json_literal +} + +func (*Json_literalContext) IsJson_literalContext() {} + +func NewJson_literalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_literalContext { + var p = new(Json_literalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_json_literal + + return p +} + +func (s *Json_literalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_literalContext) JSON_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserJSON_SYMBOL, 0) +} + +func (s *Json_literalContext) String_literal() IString_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_literalContext) +} + +func (s *Json_literalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_literalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_literalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterJson_literal(s) + } +} + +func (s *Json_literalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitJson_literal(s) + } +} + +func (s *Json_literalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitJson_literal(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Json_literal() (localctx IJson_literalContext) { + localctx = NewJson_literalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1226, GoogleSQLParserRULE_json_literal) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6938) + p.Match(GoogleSQLParserJSON_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6939) + p.string_literal(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBignumeric_literalContext is an interface to support dynamic dispatch. +type IBignumeric_literalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Bignumeric_literal_prefix() IBignumeric_literal_prefixContext + String_literal() IString_literalContext + + // IsBignumeric_literalContext differentiates from other interfaces. + IsBignumeric_literalContext() +} + +type Bignumeric_literalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBignumeric_literalContext() *Bignumeric_literalContext { + var p = new(Bignumeric_literalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_bignumeric_literal + return p +} + +func InitEmptyBignumeric_literalContext(p *Bignumeric_literalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_bignumeric_literal +} + +func (*Bignumeric_literalContext) IsBignumeric_literalContext() {} + +func NewBignumeric_literalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Bignumeric_literalContext { + var p = new(Bignumeric_literalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_bignumeric_literal + + return p +} + +func (s *Bignumeric_literalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Bignumeric_literalContext) Bignumeric_literal_prefix() IBignumeric_literal_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBignumeric_literal_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBignumeric_literal_prefixContext) +} + +func (s *Bignumeric_literalContext) String_literal() IString_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_literalContext) +} + +func (s *Bignumeric_literalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Bignumeric_literalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Bignumeric_literalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterBignumeric_literal(s) + } +} + +func (s *Bignumeric_literalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitBignumeric_literal(s) + } +} + +func (s *Bignumeric_literalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitBignumeric_literal(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Bignumeric_literal() (localctx IBignumeric_literalContext) { + localctx = NewBignumeric_literalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1228, GoogleSQLParserRULE_bignumeric_literal) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6941) + p.Bignumeric_literal_prefix() + } + { + p.SetState(6942) + p.string_literal(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBignumeric_literal_prefixContext is an interface to support dynamic dispatch. +type IBignumeric_literal_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BIGNUMERIC_SYMBOL() antlr.TerminalNode + BIGDECIMAL_SYMBOL() antlr.TerminalNode + + // IsBignumeric_literal_prefixContext differentiates from other interfaces. + IsBignumeric_literal_prefixContext() +} + +type Bignumeric_literal_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBignumeric_literal_prefixContext() *Bignumeric_literal_prefixContext { + var p = new(Bignumeric_literal_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_bignumeric_literal_prefix + return p +} + +func InitEmptyBignumeric_literal_prefixContext(p *Bignumeric_literal_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_bignumeric_literal_prefix +} + +func (*Bignumeric_literal_prefixContext) IsBignumeric_literal_prefixContext() {} + +func NewBignumeric_literal_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Bignumeric_literal_prefixContext { + var p = new(Bignumeric_literal_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_bignumeric_literal_prefix + + return p +} + +func (s *Bignumeric_literal_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Bignumeric_literal_prefixContext) BIGNUMERIC_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBIGNUMERIC_SYMBOL, 0) +} + +func (s *Bignumeric_literal_prefixContext) BIGDECIMAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBIGDECIMAL_SYMBOL, 0) +} + +func (s *Bignumeric_literal_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Bignumeric_literal_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Bignumeric_literal_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterBignumeric_literal_prefix(s) + } +} + +func (s *Bignumeric_literal_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitBignumeric_literal_prefix(s) + } +} + +func (s *Bignumeric_literal_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitBignumeric_literal_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Bignumeric_literal_prefix() (localctx IBignumeric_literal_prefixContext) { + localctx = NewBignumeric_literal_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1230, GoogleSQLParserRULE_bignumeric_literal_prefix) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6944) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserBIGNUMERIC_SYMBOL || _la == GoogleSQLParserBIGDECIMAL_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INumeric_literalContext is an interface to support dynamic dispatch. +type INumeric_literalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Numeric_literal_prefix() INumeric_literal_prefixContext + String_literal() IString_literalContext + + // IsNumeric_literalContext differentiates from other interfaces. + IsNumeric_literalContext() +} + +type Numeric_literalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNumeric_literalContext() *Numeric_literalContext { + var p = new(Numeric_literalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_numeric_literal + return p +} + +func InitEmptyNumeric_literalContext(p *Numeric_literalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_numeric_literal +} + +func (*Numeric_literalContext) IsNumeric_literalContext() {} + +func NewNumeric_literalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Numeric_literalContext { + var p = new(Numeric_literalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_numeric_literal + + return p +} + +func (s *Numeric_literalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Numeric_literalContext) Numeric_literal_prefix() INumeric_literal_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumeric_literal_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumeric_literal_prefixContext) +} + +func (s *Numeric_literalContext) String_literal() IString_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_literalContext) +} + +func (s *Numeric_literalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Numeric_literalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Numeric_literalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterNumeric_literal(s) + } +} + +func (s *Numeric_literalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitNumeric_literal(s) + } +} + +func (s *Numeric_literalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitNumeric_literal(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Numeric_literal() (localctx INumeric_literalContext) { + localctx = NewNumeric_literalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1232, GoogleSQLParserRULE_numeric_literal) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6946) + p.Numeric_literal_prefix() + } + { + p.SetState(6947) + p.string_literal(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INumeric_literal_prefixContext is an interface to support dynamic dispatch. +type INumeric_literal_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NUMERIC_SYMBOL() antlr.TerminalNode + DECIMAL_SYMBOL() antlr.TerminalNode + + // IsNumeric_literal_prefixContext differentiates from other interfaces. + IsNumeric_literal_prefixContext() +} + +type Numeric_literal_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNumeric_literal_prefixContext() *Numeric_literal_prefixContext { + var p = new(Numeric_literal_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_numeric_literal_prefix + return p +} + +func InitEmptyNumeric_literal_prefixContext(p *Numeric_literal_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_numeric_literal_prefix +} + +func (*Numeric_literal_prefixContext) IsNumeric_literal_prefixContext() {} + +func NewNumeric_literal_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Numeric_literal_prefixContext { + var p = new(Numeric_literal_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_numeric_literal_prefix + + return p +} + +func (s *Numeric_literal_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Numeric_literal_prefixContext) NUMERIC_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNUMERIC_SYMBOL, 0) +} + +func (s *Numeric_literal_prefixContext) DECIMAL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserDECIMAL_SYMBOL, 0) +} + +func (s *Numeric_literal_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Numeric_literal_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Numeric_literal_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterNumeric_literal_prefix(s) + } +} + +func (s *Numeric_literal_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitNumeric_literal_prefix(s) + } +} + +func (s *Numeric_literal_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitNumeric_literal_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Numeric_literal_prefix() (localctx INumeric_literal_prefixContext) { + localctx = NewNumeric_literal_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1234, GoogleSQLParserRULE_numeric_literal_prefix) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6949) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserNUMERIC_SYMBOL || _la == GoogleSQLParserDECIMAL_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInteger_literalContext is an interface to support dynamic dispatch. +type IInteger_literalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INTEGER_LITERAL() antlr.TerminalNode + + // IsInteger_literalContext differentiates from other interfaces. + IsInteger_literalContext() +} + +type Integer_literalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInteger_literalContext() *Integer_literalContext { + var p = new(Integer_literalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_integer_literal + return p +} + +func InitEmptyInteger_literalContext(p *Integer_literalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_integer_literal +} + +func (*Integer_literalContext) IsInteger_literalContext() {} + +func NewInteger_literalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Integer_literalContext { + var p = new(Integer_literalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_integer_literal + + return p +} + +func (s *Integer_literalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Integer_literalContext) INTEGER_LITERAL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserINTEGER_LITERAL, 0) +} + +func (s *Integer_literalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Integer_literalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Integer_literalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterInteger_literal(s) + } +} + +func (s *Integer_literalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitInteger_literal(s) + } +} + +func (s *Integer_literalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitInteger_literal(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Integer_literal() (localctx IInteger_literalContext) { + localctx = NewInteger_literalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1236, GoogleSQLParserRULE_integer_literal) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6951) + p.Match(GoogleSQLParserINTEGER_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBytes_literalContext is an interface to support dynamic dispatch. +type IBytes_literalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Bytes_literal_component() IBytes_literal_componentContext + Bytes_literal() IBytes_literalContext + String_literal_component() IString_literal_componentContext + + // IsBytes_literalContext differentiates from other interfaces. + IsBytes_literalContext() +} + +type Bytes_literalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBytes_literalContext() *Bytes_literalContext { + var p = new(Bytes_literalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_bytes_literal + return p +} + +func InitEmptyBytes_literalContext(p *Bytes_literalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_bytes_literal +} + +func (*Bytes_literalContext) IsBytes_literalContext() {} + +func NewBytes_literalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Bytes_literalContext { + var p = new(Bytes_literalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_bytes_literal + + return p +} + +func (s *Bytes_literalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Bytes_literalContext) Bytes_literal_component() IBytes_literal_componentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBytes_literal_componentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBytes_literal_componentContext) +} + +func (s *Bytes_literalContext) Bytes_literal() IBytes_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBytes_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBytes_literalContext) +} + +func (s *Bytes_literalContext) String_literal_component() IString_literal_componentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_literal_componentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_literal_componentContext) +} + +func (s *Bytes_literalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Bytes_literalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Bytes_literalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterBytes_literal(s) + } +} + +func (s *Bytes_literalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitBytes_literal(s) + } +} + +func (s *Bytes_literalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitBytes_literal(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Bytes_literal() (localctx IBytes_literalContext) { + return p.bytes_literal(0) +} + +func (p *GoogleSQLParser) bytes_literal(_p int) (localctx IBytes_literalContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewBytes_literalContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IBytes_literalContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 1238 + p.EnterRecursionRule(localctx, 1238, GoogleSQLParserRULE_bytes_literal, _p) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6954) + p.Bytes_literal_component() + } + + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(6966) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 847, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + p.SetState(6964) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 846, p.GetParserRuleContext()) { + case 1: + localctx = NewBytes_literalContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_bytes_literal) + p.SetState(6956) + + if !(p.Precpred(p.GetParserRuleContext(), 2)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) + goto errorExit + } + { + p.SetState(6957) + p.Bytes_literal_component() + } + + literalStopIndex, componentStartIndex := localctx.Bytes_literal().GetStop().GetStop(), localctx.Bytes_literal_component().GetStart().GetStart() + if literalStopIndex+1 == componentStartIndex { + p.NotifyErrorListeners("Syntax error: concatenated bytes literals must be separated by whitespace or comments.", nil, nil) + } + + case 2: + localctx = NewBytes_literalContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_bytes_literal) + p.SetState(6960) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(6961) + p.String_literal_component() + } + p.NotifyErrorListeners("Syntax error: string and bytes literals cannot be concatenated.", nil, + nil) + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(6968) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 847, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INull_literalContext is an interface to support dynamic dispatch. +type INull_literalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NULL_SYMBOL() antlr.TerminalNode + + // IsNull_literalContext differentiates from other interfaces. + IsNull_literalContext() +} + +type Null_literalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNull_literalContext() *Null_literalContext { + var p = new(Null_literalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_null_literal + return p +} + +func InitEmptyNull_literalContext(p *Null_literalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_null_literal +} + +func (*Null_literalContext) IsNull_literalContext() {} + +func NewNull_literalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Null_literalContext { + var p = new(Null_literalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_null_literal + + return p +} + +func (s *Null_literalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Null_literalContext) NULL_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserNULL_SYMBOL, 0) +} + +func (s *Null_literalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Null_literalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Null_literalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterNull_literal(s) + } +} + +func (s *Null_literalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitNull_literal(s) + } +} + +func (s *Null_literalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitNull_literal(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Null_literal() (localctx INull_literalContext) { + localctx = NewNull_literalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1240, GoogleSQLParserRULE_null_literal) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6969) + p.Match(GoogleSQLParserNULL_SYMBOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBoolean_literalContext is an interface to support dynamic dispatch. +type IBoolean_literalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRUE_SYMBOL() antlr.TerminalNode + FALSE_SYMBOL() antlr.TerminalNode + + // IsBoolean_literalContext differentiates from other interfaces. + IsBoolean_literalContext() +} + +type Boolean_literalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBoolean_literalContext() *Boolean_literalContext { + var p = new(Boolean_literalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_boolean_literal + return p +} + +func InitEmptyBoolean_literalContext(p *Boolean_literalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_boolean_literal +} + +func (*Boolean_literalContext) IsBoolean_literalContext() {} + +func NewBoolean_literalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Boolean_literalContext { + var p = new(Boolean_literalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_boolean_literal + + return p +} + +func (s *Boolean_literalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Boolean_literalContext) TRUE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserTRUE_SYMBOL, 0) +} + +func (s *Boolean_literalContext) FALSE_SYMBOL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserFALSE_SYMBOL, 0) +} + +func (s *Boolean_literalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Boolean_literalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Boolean_literalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterBoolean_literal(s) + } +} + +func (s *Boolean_literalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitBoolean_literal(s) + } +} + +func (s *Boolean_literalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitBoolean_literal(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Boolean_literal() (localctx IBoolean_literalContext) { + localctx = NewBoolean_literalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1242, GoogleSQLParserRULE_boolean_literal) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6971) + _la = p.GetTokenStream().LA(1) + + if !(_la == GoogleSQLParserTRUE_SYMBOL || _la == GoogleSQLParserFALSE_SYMBOL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IString_literalContext is an interface to support dynamic dispatch. +type IString_literalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + String_literal_component() IString_literal_componentContext + String_literal() IString_literalContext + Bytes_literal_component() IBytes_literal_componentContext + + // IsString_literalContext differentiates from other interfaces. + IsString_literalContext() +} + +type String_literalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyString_literalContext() *String_literalContext { + var p = new(String_literalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_string_literal + return p +} + +func InitEmptyString_literalContext(p *String_literalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_string_literal +} + +func (*String_literalContext) IsString_literalContext() {} + +func NewString_literalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *String_literalContext { + var p = new(String_literalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_string_literal + + return p +} + +func (s *String_literalContext) GetParser() antlr.Parser { return s.parser } + +func (s *String_literalContext) String_literal_component() IString_literal_componentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_literal_componentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_literal_componentContext) +} + +func (s *String_literalContext) String_literal() IString_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_literalContext) +} + +func (s *String_literalContext) Bytes_literal_component() IBytes_literal_componentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBytes_literal_componentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBytes_literal_componentContext) +} + +func (s *String_literalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *String_literalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *String_literalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterString_literal(s) + } +} + +func (s *String_literalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitString_literal(s) + } +} + +func (s *String_literalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitString_literal(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) String_literal() (localctx IString_literalContext) { + return p.string_literal(0) +} + +func (p *GoogleSQLParser) string_literal(_p int) (localctx IString_literalContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewString_literalContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IString_literalContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 1244 + p.EnterRecursionRule(localctx, 1244, GoogleSQLParserRULE_string_literal, _p) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6974) + p.String_literal_component() + } + + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(6986) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 849, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + p.SetState(6984) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 848, p.GetParserRuleContext()) { + case 1: + localctx = NewString_literalContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_string_literal) + p.SetState(6976) + + if !(p.Precpred(p.GetParserRuleContext(), 2)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) + goto errorExit + } + { + p.SetState(6977) + p.String_literal_component() + } + + literalStopIndex, componentStartIndex := localctx.String_literal().GetStop().GetStop(), localctx.String_literal_component().GetStart().GetStart() + if literalStopIndex+1 == componentStartIndex { + p.NotifyErrorListeners("Syntax error: concatenated string literals must be separated by whitespace or comments.", nil, nil) + } + + case 2: + localctx = NewString_literalContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, GoogleSQLParserRULE_string_literal) + p.SetState(6980) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(6981) + p.Bytes_literal_component() + } + p.NotifyErrorListeners("Syntax error: string and bytes literals cannot be concatenated.", nil, nil) + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(6988) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 849, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IString_literal_componentContext is an interface to support dynamic dispatch. +type IString_literal_componentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STRING_LITERAL() antlr.TerminalNode + + // IsString_literal_componentContext differentiates from other interfaces. + IsString_literal_componentContext() +} + +type String_literal_componentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyString_literal_componentContext() *String_literal_componentContext { + var p = new(String_literal_componentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_string_literal_component + return p +} + +func InitEmptyString_literal_componentContext(p *String_literal_componentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_string_literal_component +} + +func (*String_literal_componentContext) IsString_literal_componentContext() {} + +func NewString_literal_componentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *String_literal_componentContext { + var p = new(String_literal_componentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_string_literal_component + + return p +} + +func (s *String_literal_componentContext) GetParser() antlr.Parser { return s.parser } + +func (s *String_literal_componentContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserSTRING_LITERAL, 0) +} + +func (s *String_literal_componentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *String_literal_componentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *String_literal_componentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterString_literal_component(s) + } +} + +func (s *String_literal_componentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitString_literal_component(s) + } +} + +func (s *String_literal_componentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitString_literal_component(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) String_literal_component() (localctx IString_literal_componentContext) { + localctx = NewString_literal_componentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1246, GoogleSQLParserRULE_string_literal_component) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6989) + p.Match(GoogleSQLParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBytes_literal_componentContext is an interface to support dynamic dispatch. +type IBytes_literal_componentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BYTES_LITERAL() antlr.TerminalNode + + // IsBytes_literal_componentContext differentiates from other interfaces. + IsBytes_literal_componentContext() +} + +type Bytes_literal_componentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBytes_literal_componentContext() *Bytes_literal_componentContext { + var p = new(Bytes_literal_componentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_bytes_literal_component + return p +} + +func InitEmptyBytes_literal_componentContext(p *Bytes_literal_componentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = GoogleSQLParserRULE_bytes_literal_component +} + +func (*Bytes_literal_componentContext) IsBytes_literal_componentContext() {} + +func NewBytes_literal_componentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Bytes_literal_componentContext { + var p = new(Bytes_literal_componentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = GoogleSQLParserRULE_bytes_literal_component + + return p +} + +func (s *Bytes_literal_componentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Bytes_literal_componentContext) BYTES_LITERAL() antlr.TerminalNode { + return s.GetToken(GoogleSQLParserBYTES_LITERAL, 0) +} + +func (s *Bytes_literal_componentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Bytes_literal_componentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Bytes_literal_componentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.EnterBytes_literal_component(s) + } +} + +func (s *Bytes_literal_componentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(GoogleSQLParserListener); ok { + listenerT.ExitBytes_literal_component(s) + } +} + +func (s *Bytes_literal_componentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case GoogleSQLParserVisitor: + return t.VisitBytes_literal_component(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *GoogleSQLParser) Bytes_literal_component() (localctx IBytes_literal_componentContext) { + localctx = NewBytes_literal_componentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1248, GoogleSQLParserRULE_bytes_literal_component) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6991) + p.Match(GoogleSQLParserBYTES_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +func (p *GoogleSQLParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool { + switch ruleIndex { + case 40: + var t *Label_expressionContext = nil + if localctx != nil { + t = localctx.(*Label_expressionContext) + } + return p.Label_expression_Sempred(t, predIndex) + + case 361: + var t *Query_set_operation_prefixContext = nil + if localctx != nil { + t = localctx.(*Query_set_operation_prefixContext) + } + return p.Query_set_operation_prefix_Sempred(t, predIndex) + + case 397: + var t *Table_primaryContext = nil + if localctx != nil { + t = localctx.(*Table_primaryContext) + } + return p.Table_primary_Sempred(t, predIndex) + + case 411: + var t *Row_pattern_exprContext = nil + if localctx != nil { + t = localctx.(*Row_pattern_exprContext) + } + return p.Row_pattern_expr_Sempred(t, predIndex) + + case 412: + var t *Row_pattern_concatenationContext = nil + if localctx != nil { + t = localctx.(*Row_pattern_concatenationContext) + } + return p.Row_pattern_concatenation_Sempred(t, predIndex) + + case 430: + var t *Dashed_path_expressionContext = nil + if localctx != nil { + t = localctx.(*Dashed_path_expressionContext) + } + return p.Dashed_path_expression_Sempred(t, predIndex) + + case 431: + var t *Dashed_identifierContext = nil + if localctx != nil { + t = localctx.(*Dashed_identifierContext) + } + return p.Dashed_identifier_Sempred(t, predIndex) + + case 432: + var t *Slashed_identifierContext = nil + if localctx != nil { + t = localctx.(*Slashed_identifierContext) + } + return p.Slashed_identifier_Sempred(t, predIndex) + + case 452: + var t *Unpivot_in_item_list_prefixContext = nil + if localctx != nil { + t = localctx.(*Unpivot_in_item_list_prefixContext) + } + return p.Unpivot_in_item_list_prefix_Sempred(t, predIndex) + + case 476: + var t *ExpressionContext = nil + if localctx != nil { + t = localctx.(*ExpressionContext) + } + return p.Expression_Sempred(t, predIndex) + + case 477: + var t *Expression_higher_prec_than_andContext = nil + if localctx != nil { + t = localctx.(*Expression_higher_prec_than_andContext) + } + return p.Expression_higher_prec_than_and_Sempred(t, predIndex) + + case 553: + var t *Generalized_path_expressionContext = nil + if localctx != nil { + t = localctx.(*Generalized_path_expressionContext) + } + return p.Generalized_path_expression_Sempred(t, predIndex) + + case 554: + var t *Generalized_extension_pathContext = nil + if localctx != nil { + t = localctx.(*Generalized_extension_pathContext) + } + return p.Generalized_extension_path_Sempred(t, predIndex) + + case 571: + var t *Braced_constructor_prefixContext = nil + if localctx != nil { + t = localctx.(*Braced_constructor_prefixContext) + } + return p.Braced_constructor_prefix_Sempred(t, predIndex) + + case 619: + var t *Bytes_literalContext = nil + if localctx != nil { + t = localctx.(*Bytes_literalContext) + } + return p.Bytes_literal_Sempred(t, predIndex) + + case 622: + var t *String_literalContext = nil + if localctx != nil { + t = localctx.(*String_literalContext) + } + return p.String_literal_Sempred(t, predIndex) + + default: + panic("No predicate with index: " + fmt.Sprint(ruleIndex)) + } +} + +func (p *GoogleSQLParser) Label_expression_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 0: + return p.Precpred(p.GetParserRuleContext(), 3) + + case 1: + return p.Precpred(p.GetParserRuleContext(), 2) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *GoogleSQLParser) Query_set_operation_prefix_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 2: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *GoogleSQLParser) Table_primary_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 3: + return p.Precpred(p.GetParserRuleContext(), 2) + + case 4: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *GoogleSQLParser) Row_pattern_expr_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 5: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *GoogleSQLParser) Row_pattern_concatenation_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 6: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *GoogleSQLParser) Dashed_path_expression_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 7: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *GoogleSQLParser) Dashed_identifier_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 8: + return p.Precpred(p.GetParserRuleContext(), 5) + + case 9: + return p.Precpred(p.GetParserRuleContext(), 3) + + case 10: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *GoogleSQLParser) Slashed_identifier_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 11: + return p.Precpred(p.GetParserRuleContext(), 2) + + case 12: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *GoogleSQLParser) Unpivot_in_item_list_prefix_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 13: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *GoogleSQLParser) Expression_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 14: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *GoogleSQLParser) Expression_higher_prec_than_and_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 15: + return p.Precpred(p.GetParserRuleContext(), 20) + + case 16: + return p.Precpred(p.GetParserRuleContext(), 19) + + case 17: + return p.Precpred(p.GetParserRuleContext(), 16) + + case 18: + return p.Precpred(p.GetParserRuleContext(), 11) + + case 19: + return p.Precpred(p.GetParserRuleContext(), 10) + + case 20: + return p.Precpred(p.GetParserRuleContext(), 9) + + case 21: + return p.Precpred(p.GetParserRuleContext(), 8) + + case 22: + return p.Precpred(p.GetParserRuleContext(), 7) + + case 23: + return p.Precpred(p.GetParserRuleContext(), 6) + + case 24: + return p.Precpred(p.GetParserRuleContext(), 5) + + case 25: + return p.Precpred(p.GetParserRuleContext(), 4) + + case 26: + return p.Precpred(p.GetParserRuleContext(), 26) + + case 27: + return p.Precpred(p.GetParserRuleContext(), 25) + + case 28: + return p.Precpred(p.GetParserRuleContext(), 24) + + case 29: + return p.Precpred(p.GetParserRuleContext(), 22) + + case 30: + return p.Precpred(p.GetParserRuleContext(), 21) + + case 31: + return p.Precpred(p.GetParserRuleContext(), 18) + + case 32: + return p.Precpred(p.GetParserRuleContext(), 17) + + case 33: + return p.Precpred(p.GetParserRuleContext(), 15) + + case 34: + return p.Precpred(p.GetParserRuleContext(), 14) + + case 35: + return p.Precpred(p.GetParserRuleContext(), 13) + + case 36: + return p.Precpred(p.GetParserRuleContext(), 12) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *GoogleSQLParser) Generalized_path_expression_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 37: + return p.Precpred(p.GetParserRuleContext(), 3) + + case 38: + return p.Precpred(p.GetParserRuleContext(), 2) + + case 39: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *GoogleSQLParser) Generalized_extension_path_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 40: + return p.Precpred(p.GetParserRuleContext(), 2) + + case 41: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *GoogleSQLParser) Braced_constructor_prefix_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 42: + return p.Precpred(p.GetParserRuleContext(), 3) + + case 43: + return p.Precpred(p.GetParserRuleContext(), 2) + + case 44: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *GoogleSQLParser) Bytes_literal_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 45: + return p.Precpred(p.GetParserRuleContext(), 2) + + case 46: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *GoogleSQLParser) String_literal_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 47: + return p.Precpred(p.GetParserRuleContext(), 2) + + case 48: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} diff --git a/googlesql/googlesqlparser_base_listener.go b/googlesql/googlesqlparser_base_listener.go new file mode 100644 index 0000000..547cd3c --- /dev/null +++ b/googlesql/googlesqlparser_base_listener.go @@ -0,0 +1,4295 @@ +// Code generated from GoogleSQLParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package googlesql // GoogleSQLParser +import "github.com/antlr4-go/antlr/v4" + +// BaseGoogleSQLParserListener is a complete listener for a parse tree produced by GoogleSQLParser. +type BaseGoogleSQLParserListener struct{} + +var _ GoogleSQLParserListener = &BaseGoogleSQLParserListener{} + +// VisitTerminal is called when a terminal node is visited. +func (s *BaseGoogleSQLParserListener) VisitTerminal(node antlr.TerminalNode) {} + +// VisitErrorNode is called when an error node is visited. +func (s *BaseGoogleSQLParserListener) VisitErrorNode(node antlr.ErrorNode) {} + +// EnterEveryRule is called when any rule is entered. +func (s *BaseGoogleSQLParserListener) EnterEveryRule(ctx antlr.ParserRuleContext) {} + +// ExitEveryRule is called when any rule is exited. +func (s *BaseGoogleSQLParserListener) ExitEveryRule(ctx antlr.ParserRuleContext) {} + +// EnterRoot is called when production root is entered. +func (s *BaseGoogleSQLParserListener) EnterRoot(ctx *RootContext) {} + +// ExitRoot is called when production root is exited. +func (s *BaseGoogleSQLParserListener) ExitRoot(ctx *RootContext) {} + +// EnterStmts is called when production stmts is entered. +func (s *BaseGoogleSQLParserListener) EnterStmts(ctx *StmtsContext) {} + +// ExitStmts is called when production stmts is exited. +func (s *BaseGoogleSQLParserListener) ExitStmts(ctx *StmtsContext) {} + +// EnterUnterminated_sql_statement is called when production unterminated_sql_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterUnterminated_sql_statement(ctx *Unterminated_sql_statementContext) { +} + +// ExitUnterminated_sql_statement is called when production unterminated_sql_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitUnterminated_sql_statement(ctx *Unterminated_sql_statementContext) { +} + +// EnterSql_statement_body is called when production sql_statement_body is entered. +func (s *BaseGoogleSQLParserListener) EnterSql_statement_body(ctx *Sql_statement_bodyContext) {} + +// ExitSql_statement_body is called when production sql_statement_body is exited. +func (s *BaseGoogleSQLParserListener) ExitSql_statement_body(ctx *Sql_statement_bodyContext) {} + +// EnterGql_statement is called when production gql_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterGql_statement(ctx *Gql_statementContext) {} + +// ExitGql_statement is called when production gql_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitGql_statement(ctx *Gql_statementContext) {} + +// EnterGraph_operation_block is called when production graph_operation_block is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_operation_block(ctx *Graph_operation_blockContext) {} + +// ExitGraph_operation_block is called when production graph_operation_block is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_operation_block(ctx *Graph_operation_blockContext) {} + +// EnterGraph_composite_query_block is called when production graph_composite_query_block is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_composite_query_block(ctx *Graph_composite_query_blockContext) { +} + +// ExitGraph_composite_query_block is called when production graph_composite_query_block is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_composite_query_block(ctx *Graph_composite_query_blockContext) { +} + +// EnterGraph_composite_query_prefix is called when production graph_composite_query_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_composite_query_prefix(ctx *Graph_composite_query_prefixContext) { +} + +// ExitGraph_composite_query_prefix is called when production graph_composite_query_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_composite_query_prefix(ctx *Graph_composite_query_prefixContext) { +} + +// EnterGraph_set_operation_metadata is called when production graph_set_operation_metadata is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_set_operation_metadata(ctx *Graph_set_operation_metadataContext) { +} + +// ExitGraph_set_operation_metadata is called when production graph_set_operation_metadata is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_set_operation_metadata(ctx *Graph_set_operation_metadataContext) { +} + +// EnterGraph_linear_query_operation is called when production graph_linear_query_operation is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_linear_query_operation(ctx *Graph_linear_query_operationContext) { +} + +// ExitGraph_linear_query_operation is called when production graph_linear_query_operation is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_linear_query_operation(ctx *Graph_linear_query_operationContext) { +} + +// EnterGraph_linear_operator_list is called when production graph_linear_operator_list is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_linear_operator_list(ctx *Graph_linear_operator_listContext) { +} + +// ExitGraph_linear_operator_list is called when production graph_linear_operator_list is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_linear_operator_list(ctx *Graph_linear_operator_listContext) { +} + +// EnterGraph_linear_operator is called when production graph_linear_operator is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_linear_operator(ctx *Graph_linear_operatorContext) {} + +// ExitGraph_linear_operator is called when production graph_linear_operator is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_linear_operator(ctx *Graph_linear_operatorContext) {} + +// EnterGraph_sample_clause is called when production graph_sample_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_sample_clause(ctx *Graph_sample_clauseContext) {} + +// ExitGraph_sample_clause is called when production graph_sample_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_sample_clause(ctx *Graph_sample_clauseContext) {} + +// EnterOpt_graph_sample_clause_suffix is called when production opt_graph_sample_clause_suffix is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_graph_sample_clause_suffix(ctx *Opt_graph_sample_clause_suffixContext) { +} + +// ExitOpt_graph_sample_clause_suffix is called when production opt_graph_sample_clause_suffix is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_graph_sample_clause_suffix(ctx *Opt_graph_sample_clause_suffixContext) { +} + +// EnterGraph_for_operator is called when production graph_for_operator is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_for_operator(ctx *Graph_for_operatorContext) {} + +// ExitGraph_for_operator is called when production graph_for_operator is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_for_operator(ctx *Graph_for_operatorContext) {} + +// EnterOpt_with_offset_and_alias_with_required_as is called when production opt_with_offset_and_alias_with_required_as is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_with_offset_and_alias_with_required_as(ctx *Opt_with_offset_and_alias_with_required_asContext) { +} + +// ExitOpt_with_offset_and_alias_with_required_as is called when production opt_with_offset_and_alias_with_required_as is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_with_offset_and_alias_with_required_as(ctx *Opt_with_offset_and_alias_with_required_asContext) { +} + +// EnterGraph_with_operator is called when production graph_with_operator is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_with_operator(ctx *Graph_with_operatorContext) {} + +// ExitGraph_with_operator is called when production graph_with_operator is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_with_operator(ctx *Graph_with_operatorContext) {} + +// EnterGraph_page_operator is called when production graph_page_operator is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_page_operator(ctx *Graph_page_operatorContext) {} + +// ExitGraph_page_operator is called when production graph_page_operator is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_page_operator(ctx *Graph_page_operatorContext) {} + +// EnterGraph_order_by_operator is called when production graph_order_by_operator is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_order_by_operator(ctx *Graph_order_by_operatorContext) { +} + +// ExitGraph_order_by_operator is called when production graph_order_by_operator is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_order_by_operator(ctx *Graph_order_by_operatorContext) { +} + +// EnterGraph_filter_operator is called when production graph_filter_operator is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_filter_operator(ctx *Graph_filter_operatorContext) {} + +// ExitGraph_filter_operator is called when production graph_filter_operator is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_filter_operator(ctx *Graph_filter_operatorContext) {} + +// EnterGraph_let_operator is called when production graph_let_operator is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_let_operator(ctx *Graph_let_operatorContext) {} + +// ExitGraph_let_operator is called when production graph_let_operator is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_let_operator(ctx *Graph_let_operatorContext) {} + +// EnterGraph_let_variable_definition_list is called when production graph_let_variable_definition_list is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_let_variable_definition_list(ctx *Graph_let_variable_definition_listContext) { +} + +// ExitGraph_let_variable_definition_list is called when production graph_let_variable_definition_list is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_let_variable_definition_list(ctx *Graph_let_variable_definition_listContext) { +} + +// EnterGraph_let_variable_definition is called when production graph_let_variable_definition is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_let_variable_definition(ctx *Graph_let_variable_definitionContext) { +} + +// ExitGraph_let_variable_definition is called when production graph_let_variable_definition is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_let_variable_definition(ctx *Graph_let_variable_definitionContext) { +} + +// EnterGraph_optional_match_operator is called when production graph_optional_match_operator is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_optional_match_operator(ctx *Graph_optional_match_operatorContext) { +} + +// ExitGraph_optional_match_operator is called when production graph_optional_match_operator is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_optional_match_operator(ctx *Graph_optional_match_operatorContext) { +} + +// EnterGraph_match_operator is called when production graph_match_operator is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_match_operator(ctx *Graph_match_operatorContext) {} + +// ExitGraph_match_operator is called when production graph_match_operator is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_match_operator(ctx *Graph_match_operatorContext) {} + +// EnterGraph_pattern is called when production graph_pattern is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_pattern(ctx *Graph_patternContext) {} + +// ExitGraph_pattern is called when production graph_pattern is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_pattern(ctx *Graph_patternContext) {} + +// EnterGraph_path_pattern_list is called when production graph_path_pattern_list is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_path_pattern_list(ctx *Graph_path_pattern_listContext) { +} + +// ExitGraph_path_pattern_list is called when production graph_path_pattern_list is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_path_pattern_list(ctx *Graph_path_pattern_listContext) { +} + +// EnterGraph_path_pattern is called when production graph_path_pattern is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_path_pattern(ctx *Graph_path_patternContext) {} + +// ExitGraph_path_pattern is called when production graph_path_pattern is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_path_pattern(ctx *Graph_path_patternContext) {} + +// EnterGraph_path_pattern_expr is called when production graph_path_pattern_expr is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_path_pattern_expr(ctx *Graph_path_pattern_exprContext) { +} + +// ExitGraph_path_pattern_expr is called when production graph_path_pattern_expr is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_path_pattern_expr(ctx *Graph_path_pattern_exprContext) { +} + +// EnterGraph_path_factor is called when production graph_path_factor is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_path_factor(ctx *Graph_path_factorContext) {} + +// ExitGraph_path_factor is called when production graph_path_factor is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_path_factor(ctx *Graph_path_factorContext) {} + +// EnterGraph_quantified_path_primary is called when production graph_quantified_path_primary is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_quantified_path_primary(ctx *Graph_quantified_path_primaryContext) { +} + +// ExitGraph_quantified_path_primary is called when production graph_quantified_path_primary is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_quantified_path_primary(ctx *Graph_quantified_path_primaryContext) { +} + +// EnterGraph_path_primary is called when production graph_path_primary is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_path_primary(ctx *Graph_path_primaryContext) {} + +// ExitGraph_path_primary is called when production graph_path_primary is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_path_primary(ctx *Graph_path_primaryContext) {} + +// EnterGraph_parenthesized_path_pattern is called when production graph_parenthesized_path_pattern is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_parenthesized_path_pattern(ctx *Graph_parenthesized_path_patternContext) { +} + +// ExitGraph_parenthesized_path_pattern is called when production graph_parenthesized_path_pattern is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_parenthesized_path_pattern(ctx *Graph_parenthesized_path_patternContext) { +} + +// EnterGraph_element_pattern is called when production graph_element_pattern is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_element_pattern(ctx *Graph_element_patternContext) {} + +// ExitGraph_element_pattern is called when production graph_element_pattern is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_element_pattern(ctx *Graph_element_patternContext) {} + +// EnterGraph_edge_pattern is called when production graph_edge_pattern is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_edge_pattern(ctx *Graph_edge_patternContext) {} + +// ExitGraph_edge_pattern is called when production graph_edge_pattern is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_edge_pattern(ctx *Graph_edge_patternContext) {} + +// EnterGraph_node_pattern is called when production graph_node_pattern is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_node_pattern(ctx *Graph_node_patternContext) {} + +// ExitGraph_node_pattern is called when production graph_node_pattern is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_node_pattern(ctx *Graph_node_patternContext) {} + +// EnterGraph_element_pattern_filler is called when production graph_element_pattern_filler is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_element_pattern_filler(ctx *Graph_element_pattern_fillerContext) { +} + +// ExitGraph_element_pattern_filler is called when production graph_element_pattern_filler is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_element_pattern_filler(ctx *Graph_element_pattern_fillerContext) { +} + +// EnterGraph_property_specification is called when production graph_property_specification is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_property_specification(ctx *Graph_property_specificationContext) { +} + +// ExitGraph_property_specification is called when production graph_property_specification is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_property_specification(ctx *Graph_property_specificationContext) { +} + +// EnterGraph_property_name_and_value is called when production graph_property_name_and_value is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_property_name_and_value(ctx *Graph_property_name_and_valueContext) { +} + +// ExitGraph_property_name_and_value is called when production graph_property_name_and_value is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_property_name_and_value(ctx *Graph_property_name_and_valueContext) { +} + +// EnterOpt_is_label_expression is called when production opt_is_label_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_is_label_expression(ctx *Opt_is_label_expressionContext) { +} + +// ExitOpt_is_label_expression is called when production opt_is_label_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_is_label_expression(ctx *Opt_is_label_expressionContext) { +} + +// EnterLabel_expression is called when production label_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterLabel_expression(ctx *Label_expressionContext) {} + +// ExitLabel_expression is called when production label_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitLabel_expression(ctx *Label_expressionContext) {} + +// EnterLabel_primary is called when production label_primary is entered. +func (s *BaseGoogleSQLParserListener) EnterLabel_primary(ctx *Label_primaryContext) {} + +// ExitLabel_primary is called when production label_primary is exited. +func (s *BaseGoogleSQLParserListener) ExitLabel_primary(ctx *Label_primaryContext) {} + +// EnterParenthesized_label_expression is called when production parenthesized_label_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterParenthesized_label_expression(ctx *Parenthesized_label_expressionContext) { +} + +// ExitParenthesized_label_expression is called when production parenthesized_label_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitParenthesized_label_expression(ctx *Parenthesized_label_expressionContext) { +} + +// EnterOpt_graph_element_identifier is called when production opt_graph_element_identifier is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_graph_element_identifier(ctx *Opt_graph_element_identifierContext) { +} + +// ExitOpt_graph_element_identifier is called when production opt_graph_element_identifier is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_graph_element_identifier(ctx *Opt_graph_element_identifierContext) { +} + +// EnterOpt_graph_path_mode_prefix is called when production opt_graph_path_mode_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_graph_path_mode_prefix(ctx *Opt_graph_path_mode_prefixContext) { +} + +// ExitOpt_graph_path_mode_prefix is called when production opt_graph_path_mode_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_graph_path_mode_prefix(ctx *Opt_graph_path_mode_prefixContext) { +} + +// EnterPath_or_paths is called when production path_or_paths is entered. +func (s *BaseGoogleSQLParserListener) EnterPath_or_paths(ctx *Path_or_pathsContext) {} + +// ExitPath_or_paths is called when production path_or_paths is exited. +func (s *BaseGoogleSQLParserListener) ExitPath_or_paths(ctx *Path_or_pathsContext) {} + +// EnterOpt_graph_path_mode is called when production opt_graph_path_mode is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_graph_path_mode(ctx *Opt_graph_path_modeContext) {} + +// ExitOpt_graph_path_mode is called when production opt_graph_path_mode is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_graph_path_mode(ctx *Opt_graph_path_modeContext) {} + +// EnterOpt_graph_search_prefix is called when production opt_graph_search_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_graph_search_prefix(ctx *Opt_graph_search_prefixContext) { +} + +// ExitOpt_graph_search_prefix is called when production opt_graph_search_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_graph_search_prefix(ctx *Opt_graph_search_prefixContext) { +} + +// EnterOpt_path_variable_assignment is called when production opt_path_variable_assignment is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_path_variable_assignment(ctx *Opt_path_variable_assignmentContext) { +} + +// ExitOpt_path_variable_assignment is called when production opt_path_variable_assignment is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_path_variable_assignment(ctx *Opt_path_variable_assignmentContext) { +} + +// EnterGraph_identifier is called when production graph_identifier is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_identifier(ctx *Graph_identifierContext) {} + +// ExitGraph_identifier is called when production graph_identifier is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_identifier(ctx *Graph_identifierContext) {} + +// EnterGraph_return_operator is called when production graph_return_operator is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_return_operator(ctx *Graph_return_operatorContext) {} + +// ExitGraph_return_operator is called when production graph_return_operator is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_return_operator(ctx *Graph_return_operatorContext) {} + +// EnterGraph_page_clause is called when production graph_page_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_page_clause(ctx *Graph_page_clauseContext) {} + +// ExitGraph_page_clause is called when production graph_page_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_page_clause(ctx *Graph_page_clauseContext) {} + +// EnterGraph_order_by_clause is called when production graph_order_by_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_order_by_clause(ctx *Graph_order_by_clauseContext) {} + +// ExitGraph_order_by_clause is called when production graph_order_by_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_order_by_clause(ctx *Graph_order_by_clauseContext) {} + +// EnterGraph_ordering_expression is called when production graph_ordering_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_ordering_expression(ctx *Graph_ordering_expressionContext) { +} + +// ExitGraph_ordering_expression is called when production graph_ordering_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_ordering_expression(ctx *Graph_ordering_expressionContext) { +} + +// EnterOpt_graph_asc_or_desc is called when production opt_graph_asc_or_desc is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_graph_asc_or_desc(ctx *Opt_graph_asc_or_descContext) {} + +// ExitOpt_graph_asc_or_desc is called when production opt_graph_asc_or_desc is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_graph_asc_or_desc(ctx *Opt_graph_asc_or_descContext) {} + +// EnterGraph_return_item_list is called when production graph_return_item_list is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_return_item_list(ctx *Graph_return_item_listContext) { +} + +// ExitGraph_return_item_list is called when production graph_return_item_list is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_return_item_list(ctx *Graph_return_item_listContext) { +} + +// EnterGraph_return_item is called when production graph_return_item is entered. +func (s *BaseGoogleSQLParserListener) EnterGraph_return_item(ctx *Graph_return_itemContext) {} + +// ExitGraph_return_item is called when production graph_return_item is exited. +func (s *BaseGoogleSQLParserListener) ExitGraph_return_item(ctx *Graph_return_itemContext) {} + +// EnterUndrop_statement is called when production undrop_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterUndrop_statement(ctx *Undrop_statementContext) {} + +// ExitUndrop_statement is called when production undrop_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitUndrop_statement(ctx *Undrop_statementContext) {} + +// EnterModule_statement is called when production module_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterModule_statement(ctx *Module_statementContext) {} + +// ExitModule_statement is called when production module_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitModule_statement(ctx *Module_statementContext) {} + +// EnterImport_statement is called when production import_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterImport_statement(ctx *Import_statementContext) {} + +// ExitImport_statement is called when production import_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitImport_statement(ctx *Import_statementContext) {} + +// EnterOpt_as_or_into_alias is called when production opt_as_or_into_alias is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_as_or_into_alias(ctx *Opt_as_or_into_aliasContext) {} + +// ExitOpt_as_or_into_alias is called when production opt_as_or_into_alias is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_as_or_into_alias(ctx *Opt_as_or_into_aliasContext) {} + +// EnterPath_expression_or_string is called when production path_expression_or_string is entered. +func (s *BaseGoogleSQLParserListener) EnterPath_expression_or_string(ctx *Path_expression_or_stringContext) { +} + +// ExitPath_expression_or_string is called when production path_expression_or_string is exited. +func (s *BaseGoogleSQLParserListener) ExitPath_expression_or_string(ctx *Path_expression_or_stringContext) { +} + +// EnterImport_type is called when production import_type is entered. +func (s *BaseGoogleSQLParserListener) EnterImport_type(ctx *Import_typeContext) {} + +// ExitImport_type is called when production import_type is exited. +func (s *BaseGoogleSQLParserListener) ExitImport_type(ctx *Import_typeContext) {} + +// EnterCall_statement is called when production call_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterCall_statement(ctx *Call_statementContext) {} + +// ExitCall_statement is called when production call_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitCall_statement(ctx *Call_statementContext) {} + +// EnterDrop_statement is called when production drop_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterDrop_statement(ctx *Drop_statementContext) {} + +// ExitDrop_statement is called when production drop_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitDrop_statement(ctx *Drop_statementContext) {} + +// EnterOpt_drop_mode is called when production opt_drop_mode is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_drop_mode(ctx *Opt_drop_modeContext) {} + +// ExitOpt_drop_mode is called when production opt_drop_mode is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_drop_mode(ctx *Opt_drop_modeContext) {} + +// EnterDrop_all_row_access_policies_statement is called when production drop_all_row_access_policies_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterDrop_all_row_access_policies_statement(ctx *Drop_all_row_access_policies_statementContext) { +} + +// ExitDrop_all_row_access_policies_statement is called when production drop_all_row_access_policies_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitDrop_all_row_access_policies_statement(ctx *Drop_all_row_access_policies_statementContext) { +} + +// EnterShow_statement is called when production show_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterShow_statement(ctx *Show_statementContext) {} + +// ExitShow_statement is called when production show_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitShow_statement(ctx *Show_statementContext) {} + +// EnterOpt_like_string_literal is called when production opt_like_string_literal is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_like_string_literal(ctx *Opt_like_string_literalContext) { +} + +// ExitOpt_like_string_literal is called when production opt_like_string_literal is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_like_string_literal(ctx *Opt_like_string_literalContext) { +} + +// EnterShow_target is called when production show_target is entered. +func (s *BaseGoogleSQLParserListener) EnterShow_target(ctx *Show_targetContext) {} + +// ExitShow_target is called when production show_target is exited. +func (s *BaseGoogleSQLParserListener) ExitShow_target(ctx *Show_targetContext) {} + +// EnterRename_statement is called when production rename_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterRename_statement(ctx *Rename_statementContext) {} + +// ExitRename_statement is called when production rename_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitRename_statement(ctx *Rename_statementContext) {} + +// EnterRevoke_statement is called when production revoke_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterRevoke_statement(ctx *Revoke_statementContext) {} + +// ExitRevoke_statement is called when production revoke_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitRevoke_statement(ctx *Revoke_statementContext) {} + +// EnterGrant_statement is called when production grant_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterGrant_statement(ctx *Grant_statementContext) {} + +// ExitGrant_statement is called when production grant_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitGrant_statement(ctx *Grant_statementContext) {} + +// EnterPrivileges is called when production privileges is entered. +func (s *BaseGoogleSQLParserListener) EnterPrivileges(ctx *PrivilegesContext) {} + +// ExitPrivileges is called when production privileges is exited. +func (s *BaseGoogleSQLParserListener) ExitPrivileges(ctx *PrivilegesContext) {} + +// EnterExport_metadata_statement is called when production export_metadata_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterExport_metadata_statement(ctx *Export_metadata_statementContext) { +} + +// ExitExport_metadata_statement is called when production export_metadata_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitExport_metadata_statement(ctx *Export_metadata_statementContext) { +} + +// EnterExport_model_statement is called when production export_model_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterExport_model_statement(ctx *Export_model_statementContext) { +} + +// ExitExport_model_statement is called when production export_model_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitExport_model_statement(ctx *Export_model_statementContext) { +} + +// EnterExport_data_statement is called when production export_data_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterExport_data_statement(ctx *Export_data_statementContext) {} + +// ExitExport_data_statement is called when production export_data_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitExport_data_statement(ctx *Export_data_statementContext) {} + +// EnterExport_data_no_query is called when production export_data_no_query is entered. +func (s *BaseGoogleSQLParserListener) EnterExport_data_no_query(ctx *Export_data_no_queryContext) {} + +// ExitExport_data_no_query is called when production export_data_no_query is exited. +func (s *BaseGoogleSQLParserListener) ExitExport_data_no_query(ctx *Export_data_no_queryContext) {} + +// EnterExplain_statement is called when production explain_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterExplain_statement(ctx *Explain_statementContext) {} + +// ExitExplain_statement is called when production explain_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitExplain_statement(ctx *Explain_statementContext) {} + +// EnterExecute_immediate is called when production execute_immediate is entered. +func (s *BaseGoogleSQLParserListener) EnterExecute_immediate(ctx *Execute_immediateContext) {} + +// ExitExecute_immediate is called when production execute_immediate is exited. +func (s *BaseGoogleSQLParserListener) ExitExecute_immediate(ctx *Execute_immediateContext) {} + +// EnterOpt_execute_into_clause is called when production opt_execute_into_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_execute_into_clause(ctx *Opt_execute_into_clauseContext) { +} + +// ExitOpt_execute_into_clause is called when production opt_execute_into_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_execute_into_clause(ctx *Opt_execute_into_clauseContext) { +} + +// EnterOpt_execute_using_clause is called when production opt_execute_using_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_execute_using_clause(ctx *Opt_execute_using_clauseContext) { +} + +// ExitOpt_execute_using_clause is called when production opt_execute_using_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_execute_using_clause(ctx *Opt_execute_using_clauseContext) { +} + +// EnterExecute_using_argument_list is called when production execute_using_argument_list is entered. +func (s *BaseGoogleSQLParserListener) EnterExecute_using_argument_list(ctx *Execute_using_argument_listContext) { +} + +// ExitExecute_using_argument_list is called when production execute_using_argument_list is exited. +func (s *BaseGoogleSQLParserListener) ExitExecute_using_argument_list(ctx *Execute_using_argument_listContext) { +} + +// EnterExecute_using_argument is called when production execute_using_argument is entered. +func (s *BaseGoogleSQLParserListener) EnterExecute_using_argument(ctx *Execute_using_argumentContext) { +} + +// ExitExecute_using_argument is called when production execute_using_argument is exited. +func (s *BaseGoogleSQLParserListener) ExitExecute_using_argument(ctx *Execute_using_argumentContext) { +} + +// EnterDescribe_statement is called when production describe_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterDescribe_statement(ctx *Describe_statementContext) {} + +// ExitDescribe_statement is called when production describe_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitDescribe_statement(ctx *Describe_statementContext) {} + +// EnterDescribe_info is called when production describe_info is entered. +func (s *BaseGoogleSQLParserListener) EnterDescribe_info(ctx *Describe_infoContext) {} + +// ExitDescribe_info is called when production describe_info is exited. +func (s *BaseGoogleSQLParserListener) ExitDescribe_info(ctx *Describe_infoContext) {} + +// EnterOpt_from_path_expression is called when production opt_from_path_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_from_path_expression(ctx *Opt_from_path_expressionContext) { +} + +// ExitOpt_from_path_expression is called when production opt_from_path_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_from_path_expression(ctx *Opt_from_path_expressionContext) { +} + +// EnterDescribe_keyword is called when production describe_keyword is entered. +func (s *BaseGoogleSQLParserListener) EnterDescribe_keyword(ctx *Describe_keywordContext) {} + +// ExitDescribe_keyword is called when production describe_keyword is exited. +func (s *BaseGoogleSQLParserListener) ExitDescribe_keyword(ctx *Describe_keywordContext) {} + +// EnterDefine_table_statement is called when production define_table_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterDefine_table_statement(ctx *Define_table_statementContext) { +} + +// ExitDefine_table_statement is called when production define_table_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitDefine_table_statement(ctx *Define_table_statementContext) { +} + +// EnterCreate_entity_statement is called when production create_entity_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterCreate_entity_statement(ctx *Create_entity_statementContext) { +} + +// ExitCreate_entity_statement is called when production create_entity_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitCreate_entity_statement(ctx *Create_entity_statementContext) { +} + +// EnterOpt_generic_entity_body is called when production opt_generic_entity_body is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_generic_entity_body(ctx *Opt_generic_entity_bodyContext) { +} + +// ExitOpt_generic_entity_body is called when production opt_generic_entity_body is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_generic_entity_body(ctx *Opt_generic_entity_bodyContext) { +} + +// EnterCreate_view_statement is called when production create_view_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterCreate_view_statement(ctx *Create_view_statementContext) {} + +// ExitCreate_view_statement is called when production create_view_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitCreate_view_statement(ctx *Create_view_statementContext) {} + +// EnterQuery_or_replica_source is called when production query_or_replica_source is entered. +func (s *BaseGoogleSQLParserListener) EnterQuery_or_replica_source(ctx *Query_or_replica_sourceContext) { +} + +// ExitQuery_or_replica_source is called when production query_or_replica_source is exited. +func (s *BaseGoogleSQLParserListener) ExitQuery_or_replica_source(ctx *Query_or_replica_sourceContext) { +} + +// EnterColumn_with_options_list is called when production column_with_options_list is entered. +func (s *BaseGoogleSQLParserListener) EnterColumn_with_options_list(ctx *Column_with_options_listContext) { +} + +// ExitColumn_with_options_list is called when production column_with_options_list is exited. +func (s *BaseGoogleSQLParserListener) ExitColumn_with_options_list(ctx *Column_with_options_listContext) { +} + +// EnterColumn_with_options is called when production column_with_options is entered. +func (s *BaseGoogleSQLParserListener) EnterColumn_with_options(ctx *Column_with_optionsContext) {} + +// ExitColumn_with_options is called when production column_with_options is exited. +func (s *BaseGoogleSQLParserListener) ExitColumn_with_options(ctx *Column_with_optionsContext) {} + +// EnterCreate_table_statement is called when production create_table_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterCreate_table_statement(ctx *Create_table_statementContext) { +} + +// ExitCreate_table_statement is called when production create_table_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitCreate_table_statement(ctx *Create_table_statementContext) { +} + +// EnterOpt_ttl_clause is called when production opt_ttl_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_ttl_clause(ctx *Opt_ttl_clauseContext) {} + +// ExitOpt_ttl_clause is called when production opt_ttl_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_ttl_clause(ctx *Opt_ttl_clauseContext) {} + +// EnterOpt_copy_table is called when production opt_copy_table is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_copy_table(ctx *Opt_copy_tableContext) {} + +// ExitOpt_copy_table is called when production opt_copy_table is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_copy_table(ctx *Opt_copy_tableContext) {} + +// EnterCopy_data_source is called when production copy_data_source is entered. +func (s *BaseGoogleSQLParserListener) EnterCopy_data_source(ctx *Copy_data_sourceContext) {} + +// ExitCopy_data_source is called when production copy_data_source is exited. +func (s *BaseGoogleSQLParserListener) ExitCopy_data_source(ctx *Copy_data_sourceContext) {} + +// EnterOpt_clone_table is called when production opt_clone_table is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_clone_table(ctx *Opt_clone_tableContext) {} + +// ExitOpt_clone_table is called when production opt_clone_table is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_clone_table(ctx *Opt_clone_tableContext) {} + +// EnterOpt_spanner_table_options is called when production opt_spanner_table_options is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_spanner_table_options(ctx *Opt_spanner_table_optionsContext) { +} + +// ExitOpt_spanner_table_options is called when production opt_spanner_table_options is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_spanner_table_options(ctx *Opt_spanner_table_optionsContext) { +} + +// EnterOpt_spanner_interleave_in_parent_clause is called when production opt_spanner_interleave_in_parent_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_spanner_interleave_in_parent_clause(ctx *Opt_spanner_interleave_in_parent_clauseContext) { +} + +// ExitOpt_spanner_interleave_in_parent_clause is called when production opt_spanner_interleave_in_parent_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_spanner_interleave_in_parent_clause(ctx *Opt_spanner_interleave_in_parent_clauseContext) { +} + +// EnterSpanner_primary_key is called when production spanner_primary_key is entered. +func (s *BaseGoogleSQLParserListener) EnterSpanner_primary_key(ctx *Spanner_primary_keyContext) {} + +// ExitSpanner_primary_key is called when production spanner_primary_key is exited. +func (s *BaseGoogleSQLParserListener) ExitSpanner_primary_key(ctx *Spanner_primary_keyContext) {} + +// EnterCreate_table_function_statement is called when production create_table_function_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterCreate_table_function_statement(ctx *Create_table_function_statementContext) { +} + +// ExitCreate_table_function_statement is called when production create_table_function_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitCreate_table_function_statement(ctx *Create_table_function_statementContext) { +} + +// EnterOpt_as_query_or_string is called when production opt_as_query_or_string is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_as_query_or_string(ctx *Opt_as_query_or_stringContext) { +} + +// ExitOpt_as_query_or_string is called when production opt_as_query_or_string is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_as_query_or_string(ctx *Opt_as_query_or_stringContext) { +} + +// EnterUnordered_language_options is called when production unordered_language_options is entered. +func (s *BaseGoogleSQLParserListener) EnterUnordered_language_options(ctx *Unordered_language_optionsContext) { +} + +// ExitUnordered_language_options is called when production unordered_language_options is exited. +func (s *BaseGoogleSQLParserListener) ExitUnordered_language_options(ctx *Unordered_language_optionsContext) { +} + +// EnterOpt_function_parameters is called when production opt_function_parameters is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_function_parameters(ctx *Opt_function_parametersContext) { +} + +// ExitOpt_function_parameters is called when production opt_function_parameters is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_function_parameters(ctx *Opt_function_parametersContext) { +} + +// EnterCreate_snapshot_statement is called when production create_snapshot_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterCreate_snapshot_statement(ctx *Create_snapshot_statementContext) { +} + +// ExitCreate_snapshot_statement is called when production create_snapshot_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitCreate_snapshot_statement(ctx *Create_snapshot_statementContext) { +} + +// EnterCreate_external_schema_statement is called when production create_external_schema_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterCreate_external_schema_statement(ctx *Create_external_schema_statementContext) { +} + +// ExitCreate_external_schema_statement is called when production create_external_schema_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitCreate_external_schema_statement(ctx *Create_external_schema_statementContext) { +} + +// EnterCreate_schema_statement is called when production create_schema_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterCreate_schema_statement(ctx *Create_schema_statementContext) { +} + +// ExitCreate_schema_statement is called when production create_schema_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitCreate_schema_statement(ctx *Create_schema_statementContext) { +} + +// EnterCreate_property_graph_statement is called when production create_property_graph_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterCreate_property_graph_statement(ctx *Create_property_graph_statementContext) { +} + +// ExitCreate_property_graph_statement is called when production create_property_graph_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitCreate_property_graph_statement(ctx *Create_property_graph_statementContext) { +} + +// EnterOpt_edge_table_clause is called when production opt_edge_table_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_edge_table_clause(ctx *Opt_edge_table_clauseContext) {} + +// ExitOpt_edge_table_clause is called when production opt_edge_table_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_edge_table_clause(ctx *Opt_edge_table_clauseContext) {} + +// EnterElement_table_list is called when production element_table_list is entered. +func (s *BaseGoogleSQLParserListener) EnterElement_table_list(ctx *Element_table_listContext) {} + +// ExitElement_table_list is called when production element_table_list is exited. +func (s *BaseGoogleSQLParserListener) ExitElement_table_list(ctx *Element_table_listContext) {} + +// EnterElement_table_definition is called when production element_table_definition is entered. +func (s *BaseGoogleSQLParserListener) EnterElement_table_definition(ctx *Element_table_definitionContext) { +} + +// ExitElement_table_definition is called when production element_table_definition is exited. +func (s *BaseGoogleSQLParserListener) ExitElement_table_definition(ctx *Element_table_definitionContext) { +} + +// EnterOpt_label_and_properties_clause is called when production opt_label_and_properties_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_label_and_properties_clause(ctx *Opt_label_and_properties_clauseContext) { +} + +// ExitOpt_label_and_properties_clause is called when production opt_label_and_properties_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_label_and_properties_clause(ctx *Opt_label_and_properties_clauseContext) { +} + +// EnterLabel_and_properties_list is called when production label_and_properties_list is entered. +func (s *BaseGoogleSQLParserListener) EnterLabel_and_properties_list(ctx *Label_and_properties_listContext) { +} + +// ExitLabel_and_properties_list is called when production label_and_properties_list is exited. +func (s *BaseGoogleSQLParserListener) ExitLabel_and_properties_list(ctx *Label_and_properties_listContext) { +} + +// EnterLabel_and_properties is called when production label_and_properties is entered. +func (s *BaseGoogleSQLParserListener) EnterLabel_and_properties(ctx *Label_and_propertiesContext) {} + +// ExitLabel_and_properties is called when production label_and_properties is exited. +func (s *BaseGoogleSQLParserListener) ExitLabel_and_properties(ctx *Label_and_propertiesContext) {} + +// EnterProperties_clause is called when production properties_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterProperties_clause(ctx *Properties_clauseContext) {} + +// ExitProperties_clause is called when production properties_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitProperties_clause(ctx *Properties_clauseContext) {} + +// EnterDerived_property_list is called when production derived_property_list is entered. +func (s *BaseGoogleSQLParserListener) EnterDerived_property_list(ctx *Derived_property_listContext) {} + +// ExitDerived_property_list is called when production derived_property_list is exited. +func (s *BaseGoogleSQLParserListener) ExitDerived_property_list(ctx *Derived_property_listContext) {} + +// EnterDerived_property is called when production derived_property is entered. +func (s *BaseGoogleSQLParserListener) EnterDerived_property(ctx *Derived_propertyContext) {} + +// ExitDerived_property is called when production derived_property is exited. +func (s *BaseGoogleSQLParserListener) ExitDerived_property(ctx *Derived_propertyContext) {} + +// EnterOpt_except_column_list is called when production opt_except_column_list is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_except_column_list(ctx *Opt_except_column_listContext) { +} + +// ExitOpt_except_column_list is called when production opt_except_column_list is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_except_column_list(ctx *Opt_except_column_listContext) { +} + +// EnterProperties_all_columns is called when production properties_all_columns is entered. +func (s *BaseGoogleSQLParserListener) EnterProperties_all_columns(ctx *Properties_all_columnsContext) { +} + +// ExitProperties_all_columns is called when production properties_all_columns is exited. +func (s *BaseGoogleSQLParserListener) ExitProperties_all_columns(ctx *Properties_all_columnsContext) { +} + +// EnterOpt_dest_node_table_clause is called when production opt_dest_node_table_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_dest_node_table_clause(ctx *Opt_dest_node_table_clauseContext) { +} + +// ExitOpt_dest_node_table_clause is called when production opt_dest_node_table_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_dest_node_table_clause(ctx *Opt_dest_node_table_clauseContext) { +} + +// EnterOpt_source_node_table_clause is called when production opt_source_node_table_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_source_node_table_clause(ctx *Opt_source_node_table_clauseContext) { +} + +// ExitOpt_source_node_table_clause is called when production opt_source_node_table_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_source_node_table_clause(ctx *Opt_source_node_table_clauseContext) { +} + +// EnterOpt_key_clause is called when production opt_key_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_key_clause(ctx *Opt_key_clauseContext) {} + +// ExitOpt_key_clause is called when production opt_key_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_key_clause(ctx *Opt_key_clauseContext) {} + +// EnterCreate_model_statement is called when production create_model_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterCreate_model_statement(ctx *Create_model_statementContext) { +} + +// ExitCreate_model_statement is called when production create_model_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitCreate_model_statement(ctx *Create_model_statementContext) { +} + +// EnterOpt_input_output_clause is called when production opt_input_output_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_input_output_clause(ctx *Opt_input_output_clauseContext) { +} + +// ExitOpt_input_output_clause is called when production opt_input_output_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_input_output_clause(ctx *Opt_input_output_clauseContext) { +} + +// EnterOpt_transform_clause is called when production opt_transform_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_transform_clause(ctx *Opt_transform_clauseContext) {} + +// ExitOpt_transform_clause is called when production opt_transform_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_transform_clause(ctx *Opt_transform_clauseContext) {} + +// EnterOpt_as_query_or_aliased_query_list is called when production opt_as_query_or_aliased_query_list is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_as_query_or_aliased_query_list(ctx *Opt_as_query_or_aliased_query_listContext) { +} + +// ExitOpt_as_query_or_aliased_query_list is called when production opt_as_query_or_aliased_query_list is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_as_query_or_aliased_query_list(ctx *Opt_as_query_or_aliased_query_listContext) { +} + +// EnterAliased_query_list is called when production aliased_query_list is entered. +func (s *BaseGoogleSQLParserListener) EnterAliased_query_list(ctx *Aliased_query_listContext) {} + +// ExitAliased_query_list is called when production aliased_query_list is exited. +func (s *BaseGoogleSQLParserListener) ExitAliased_query_list(ctx *Aliased_query_listContext) {} + +// EnterAs_query is called when production as_query is entered. +func (s *BaseGoogleSQLParserListener) EnterAs_query(ctx *As_queryContext) {} + +// ExitAs_query is called when production as_query is exited. +func (s *BaseGoogleSQLParserListener) ExitAs_query(ctx *As_queryContext) {} + +// EnterCreate_external_table_function_statement is called when production create_external_table_function_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterCreate_external_table_function_statement(ctx *Create_external_table_function_statementContext) { +} + +// ExitCreate_external_table_function_statement is called when production create_external_table_function_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitCreate_external_table_function_statement(ctx *Create_external_table_function_statementContext) { +} + +// EnterCreate_external_table_statement is called when production create_external_table_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterCreate_external_table_statement(ctx *Create_external_table_statementContext) { +} + +// ExitCreate_external_table_statement is called when production create_external_table_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitCreate_external_table_statement(ctx *Create_external_table_statementContext) { +} + +// EnterOpt_default_collate_clause is called when production opt_default_collate_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_default_collate_clause(ctx *Opt_default_collate_clauseContext) { +} + +// ExitOpt_default_collate_clause is called when production opt_default_collate_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_default_collate_clause(ctx *Opt_default_collate_clauseContext) { +} + +// EnterOpt_like_path_expression is called when production opt_like_path_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_like_path_expression(ctx *Opt_like_path_expressionContext) { +} + +// ExitOpt_like_path_expression is called when production opt_like_path_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_like_path_expression(ctx *Opt_like_path_expressionContext) { +} + +// EnterCreate_row_access_policy_statement is called when production create_row_access_policy_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterCreate_row_access_policy_statement(ctx *Create_row_access_policy_statementContext) { +} + +// ExitCreate_row_access_policy_statement is called when production create_row_access_policy_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitCreate_row_access_policy_statement(ctx *Create_row_access_policy_statementContext) { +} + +// EnterFilter_using_clause is called when production filter_using_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterFilter_using_clause(ctx *Filter_using_clauseContext) {} + +// ExitFilter_using_clause is called when production filter_using_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitFilter_using_clause(ctx *Filter_using_clauseContext) {} + +// EnterCreate_row_access_policy_grant_to_clause is called when production create_row_access_policy_grant_to_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterCreate_row_access_policy_grant_to_clause(ctx *Create_row_access_policy_grant_to_clauseContext) { +} + +// ExitCreate_row_access_policy_grant_to_clause is called when production create_row_access_policy_grant_to_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitCreate_row_access_policy_grant_to_clause(ctx *Create_row_access_policy_grant_to_clauseContext) { +} + +// EnterCreate_privilege_restriction_statement is called when production create_privilege_restriction_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterCreate_privilege_restriction_statement(ctx *Create_privilege_restriction_statementContext) { +} + +// ExitCreate_privilege_restriction_statement is called when production create_privilege_restriction_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitCreate_privilege_restriction_statement(ctx *Create_privilege_restriction_statementContext) { +} + +// EnterRestrict_to_clause is called when production restrict_to_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterRestrict_to_clause(ctx *Restrict_to_clauseContext) {} + +// ExitRestrict_to_clause is called when production restrict_to_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitRestrict_to_clause(ctx *Restrict_to_clauseContext) {} + +// EnterPossibly_empty_grantee_list is called when production possibly_empty_grantee_list is entered. +func (s *BaseGoogleSQLParserListener) EnterPossibly_empty_grantee_list(ctx *Possibly_empty_grantee_listContext) { +} + +// ExitPossibly_empty_grantee_list is called when production possibly_empty_grantee_list is exited. +func (s *BaseGoogleSQLParserListener) ExitPossibly_empty_grantee_list(ctx *Possibly_empty_grantee_listContext) { +} + +// EnterCreate_index_statement is called when production create_index_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterCreate_index_statement(ctx *Create_index_statementContext) { +} + +// ExitCreate_index_statement is called when production create_index_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitCreate_index_statement(ctx *Create_index_statementContext) { +} + +// EnterOpt_create_index_statement_suffix is called when production opt_create_index_statement_suffix is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_create_index_statement_suffix(ctx *Opt_create_index_statement_suffixContext) { +} + +// ExitOpt_create_index_statement_suffix is called when production opt_create_index_statement_suffix is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_create_index_statement_suffix(ctx *Opt_create_index_statement_suffixContext) { +} + +// EnterSpanner_index_interleave_clause is called when production spanner_index_interleave_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterSpanner_index_interleave_clause(ctx *Spanner_index_interleave_clauseContext) { +} + +// ExitSpanner_index_interleave_clause is called when production spanner_index_interleave_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitSpanner_index_interleave_clause(ctx *Spanner_index_interleave_clauseContext) { +} + +// EnterIndex_storing_list is called when production index_storing_list is entered. +func (s *BaseGoogleSQLParserListener) EnterIndex_storing_list(ctx *Index_storing_listContext) {} + +// ExitIndex_storing_list is called when production index_storing_list is exited. +func (s *BaseGoogleSQLParserListener) ExitIndex_storing_list(ctx *Index_storing_listContext) {} + +// EnterIndex_storing_expression_list is called when production index_storing_expression_list is entered. +func (s *BaseGoogleSQLParserListener) EnterIndex_storing_expression_list(ctx *Index_storing_expression_listContext) { +} + +// ExitIndex_storing_expression_list is called when production index_storing_expression_list is exited. +func (s *BaseGoogleSQLParserListener) ExitIndex_storing_expression_list(ctx *Index_storing_expression_listContext) { +} + +// EnterIndex_order_by_and_options is called when production index_order_by_and_options is entered. +func (s *BaseGoogleSQLParserListener) EnterIndex_order_by_and_options(ctx *Index_order_by_and_optionsContext) { +} + +// ExitIndex_order_by_and_options is called when production index_order_by_and_options is exited. +func (s *BaseGoogleSQLParserListener) ExitIndex_order_by_and_options(ctx *Index_order_by_and_optionsContext) { +} + +// EnterIndex_all_columns is called when production index_all_columns is entered. +func (s *BaseGoogleSQLParserListener) EnterIndex_all_columns(ctx *Index_all_columnsContext) {} + +// ExitIndex_all_columns is called when production index_all_columns is exited. +func (s *BaseGoogleSQLParserListener) ExitIndex_all_columns(ctx *Index_all_columnsContext) {} + +// EnterOpt_with_column_options is called when production opt_with_column_options is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_with_column_options(ctx *Opt_with_column_optionsContext) { +} + +// ExitOpt_with_column_options is called when production opt_with_column_options is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_with_column_options(ctx *Opt_with_column_optionsContext) { +} + +// EnterAll_column_column_options is called when production all_column_column_options is entered. +func (s *BaseGoogleSQLParserListener) EnterAll_column_column_options(ctx *All_column_column_optionsContext) { +} + +// ExitAll_column_column_options is called when production all_column_column_options is exited. +func (s *BaseGoogleSQLParserListener) ExitAll_column_column_options(ctx *All_column_column_optionsContext) { +} + +// EnterColumn_ordering_and_options_expr is called when production column_ordering_and_options_expr is entered. +func (s *BaseGoogleSQLParserListener) EnterColumn_ordering_and_options_expr(ctx *Column_ordering_and_options_exprContext) { +} + +// ExitColumn_ordering_and_options_expr is called when production column_ordering_and_options_expr is exited. +func (s *BaseGoogleSQLParserListener) ExitColumn_ordering_and_options_expr(ctx *Column_ordering_and_options_exprContext) { +} + +// EnterIndex_unnest_expression_list is called when production index_unnest_expression_list is entered. +func (s *BaseGoogleSQLParserListener) EnterIndex_unnest_expression_list(ctx *Index_unnest_expression_listContext) { +} + +// ExitIndex_unnest_expression_list is called when production index_unnest_expression_list is exited. +func (s *BaseGoogleSQLParserListener) ExitIndex_unnest_expression_list(ctx *Index_unnest_expression_listContext) { +} + +// EnterUnnest_expression_with_opt_alias_and_offset is called when production unnest_expression_with_opt_alias_and_offset is entered. +func (s *BaseGoogleSQLParserListener) EnterUnnest_expression_with_opt_alias_and_offset(ctx *Unnest_expression_with_opt_alias_and_offsetContext) { +} + +// ExitUnnest_expression_with_opt_alias_and_offset is called when production unnest_expression_with_opt_alias_and_offset is exited. +func (s *BaseGoogleSQLParserListener) ExitUnnest_expression_with_opt_alias_and_offset(ctx *Unnest_expression_with_opt_alias_and_offsetContext) { +} + +// EnterOn_path_expression is called when production on_path_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterOn_path_expression(ctx *On_path_expressionContext) {} + +// ExitOn_path_expression is called when production on_path_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitOn_path_expression(ctx *On_path_expressionContext) {} + +// EnterIndex_type is called when production index_type is entered. +func (s *BaseGoogleSQLParserListener) EnterIndex_type(ctx *Index_typeContext) {} + +// ExitIndex_type is called when production index_type is exited. +func (s *BaseGoogleSQLParserListener) ExitIndex_type(ctx *Index_typeContext) {} + +// EnterOpt_spanner_null_filtered is called when production opt_spanner_null_filtered is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_spanner_null_filtered(ctx *Opt_spanner_null_filteredContext) { +} + +// ExitOpt_spanner_null_filtered is called when production opt_spanner_null_filtered is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_spanner_null_filtered(ctx *Opt_spanner_null_filteredContext) { +} + +// EnterCreate_procedure_statement is called when production create_procedure_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterCreate_procedure_statement(ctx *Create_procedure_statementContext) { +} + +// ExitCreate_procedure_statement is called when production create_procedure_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitCreate_procedure_statement(ctx *Create_procedure_statementContext) { +} + +// EnterBegin_end_block_or_language_as_code is called when production begin_end_block_or_language_as_code is entered. +func (s *BaseGoogleSQLParserListener) EnterBegin_end_block_or_language_as_code(ctx *Begin_end_block_or_language_as_codeContext) { +} + +// ExitBegin_end_block_or_language_as_code is called when production begin_end_block_or_language_as_code is exited. +func (s *BaseGoogleSQLParserListener) ExitBegin_end_block_or_language_as_code(ctx *Begin_end_block_or_language_as_codeContext) { +} + +// EnterBegin_end_block is called when production begin_end_block is entered. +func (s *BaseGoogleSQLParserListener) EnterBegin_end_block(ctx *Begin_end_blockContext) {} + +// ExitBegin_end_block is called when production begin_end_block is exited. +func (s *BaseGoogleSQLParserListener) ExitBegin_end_block(ctx *Begin_end_blockContext) {} + +// EnterOpt_exception_handler is called when production opt_exception_handler is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_exception_handler(ctx *Opt_exception_handlerContext) {} + +// ExitOpt_exception_handler is called when production opt_exception_handler is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_exception_handler(ctx *Opt_exception_handlerContext) {} + +// EnterStatement_list is called when production statement_list is entered. +func (s *BaseGoogleSQLParserListener) EnterStatement_list(ctx *Statement_listContext) {} + +// ExitStatement_list is called when production statement_list is exited. +func (s *BaseGoogleSQLParserListener) ExitStatement_list(ctx *Statement_listContext) {} + +// EnterUnterminated_non_empty_statement_list is called when production unterminated_non_empty_statement_list is entered. +func (s *BaseGoogleSQLParserListener) EnterUnterminated_non_empty_statement_list(ctx *Unterminated_non_empty_statement_listContext) { +} + +// ExitUnterminated_non_empty_statement_list is called when production unterminated_non_empty_statement_list is exited. +func (s *BaseGoogleSQLParserListener) ExitUnterminated_non_empty_statement_list(ctx *Unterminated_non_empty_statement_listContext) { +} + +// EnterUnterminated_statement is called when production unterminated_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterUnterminated_statement(ctx *Unterminated_statementContext) { +} + +// ExitUnterminated_statement is called when production unterminated_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitUnterminated_statement(ctx *Unterminated_statementContext) { +} + +// EnterUnterminated_script_statement is called when production unterminated_script_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterUnterminated_script_statement(ctx *Unterminated_script_statementContext) { +} + +// ExitUnterminated_script_statement is called when production unterminated_script_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitUnterminated_script_statement(ctx *Unterminated_script_statementContext) { +} + +// EnterLabel is called when production label is entered. +func (s *BaseGoogleSQLParserListener) EnterLabel(ctx *LabelContext) {} + +// ExitLabel is called when production label is exited. +func (s *BaseGoogleSQLParserListener) ExitLabel(ctx *LabelContext) {} + +// EnterUnterminated_unlabeled_script_statement is called when production unterminated_unlabeled_script_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterUnterminated_unlabeled_script_statement(ctx *Unterminated_unlabeled_script_statementContext) { +} + +// ExitUnterminated_unlabeled_script_statement is called when production unterminated_unlabeled_script_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitUnterminated_unlabeled_script_statement(ctx *Unterminated_unlabeled_script_statementContext) { +} + +// EnterFor_in_statement is called when production for_in_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterFor_in_statement(ctx *For_in_statementContext) {} + +// ExitFor_in_statement is called when production for_in_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitFor_in_statement(ctx *For_in_statementContext) {} + +// EnterRepeat_statement is called when production repeat_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterRepeat_statement(ctx *Repeat_statementContext) {} + +// ExitRepeat_statement is called when production repeat_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitRepeat_statement(ctx *Repeat_statementContext) {} + +// EnterUntil_clause is called when production until_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterUntil_clause(ctx *Until_clauseContext) {} + +// ExitUntil_clause is called when production until_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitUntil_clause(ctx *Until_clauseContext) {} + +// EnterLoop_statement is called when production loop_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterLoop_statement(ctx *Loop_statementContext) {} + +// ExitLoop_statement is called when production loop_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitLoop_statement(ctx *Loop_statementContext) {} + +// EnterWhile_statement is called when production while_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterWhile_statement(ctx *While_statementContext) {} + +// ExitWhile_statement is called when production while_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitWhile_statement(ctx *While_statementContext) {} + +// EnterRaise_statement is called when production raise_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterRaise_statement(ctx *Raise_statementContext) {} + +// ExitRaise_statement is called when production raise_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitRaise_statement(ctx *Raise_statementContext) {} + +// EnterReturn_statement is called when production return_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterReturn_statement(ctx *Return_statementContext) {} + +// ExitReturn_statement is called when production return_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitReturn_statement(ctx *Return_statementContext) {} + +// EnterContinue_statement is called when production continue_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterContinue_statement(ctx *Continue_statementContext) {} + +// ExitContinue_statement is called when production continue_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitContinue_statement(ctx *Continue_statementContext) {} + +// EnterVariable_declaration is called when production variable_declaration is entered. +func (s *BaseGoogleSQLParserListener) EnterVariable_declaration(ctx *Variable_declarationContext) {} + +// ExitVariable_declaration is called when production variable_declaration is exited. +func (s *BaseGoogleSQLParserListener) ExitVariable_declaration(ctx *Variable_declarationContext) {} + +// EnterBreak_statement is called when production break_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterBreak_statement(ctx *Break_statementContext) {} + +// ExitBreak_statement is called when production break_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitBreak_statement(ctx *Break_statementContext) {} + +// EnterCase_statement is called when production case_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterCase_statement(ctx *Case_statementContext) {} + +// ExitCase_statement is called when production case_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitCase_statement(ctx *Case_statementContext) {} + +// EnterWhen_then_clauses is called when production when_then_clauses is entered. +func (s *BaseGoogleSQLParserListener) EnterWhen_then_clauses(ctx *When_then_clausesContext) {} + +// ExitWhen_then_clauses is called when production when_then_clauses is exited. +func (s *BaseGoogleSQLParserListener) ExitWhen_then_clauses(ctx *When_then_clausesContext) {} + +// EnterIf_statement is called when production if_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterIf_statement(ctx *If_statementContext) {} + +// ExitIf_statement is called when production if_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitIf_statement(ctx *If_statementContext) {} + +// EnterElseif_clauses is called when production elseif_clauses is entered. +func (s *BaseGoogleSQLParserListener) EnterElseif_clauses(ctx *Elseif_clausesContext) {} + +// ExitElseif_clauses is called when production elseif_clauses is exited. +func (s *BaseGoogleSQLParserListener) ExitElseif_clauses(ctx *Elseif_clausesContext) {} + +// EnterOpt_else is called when production opt_else is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_else(ctx *Opt_elseContext) {} + +// ExitOpt_else is called when production opt_else is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_else(ctx *Opt_elseContext) {} + +// EnterOpt_as_code is called when production opt_as_code is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_as_code(ctx *Opt_as_codeContext) {} + +// ExitOpt_as_code is called when production opt_as_code is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_as_code(ctx *Opt_as_codeContext) {} + +// EnterOpt_external_security_clause is called when production opt_external_security_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_external_security_clause(ctx *Opt_external_security_clauseContext) { +} + +// ExitOpt_external_security_clause is called when production opt_external_security_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_external_security_clause(ctx *Opt_external_security_clauseContext) { +} + +// EnterExternal_security_clause_kind is called when production external_security_clause_kind is entered. +func (s *BaseGoogleSQLParserListener) EnterExternal_security_clause_kind(ctx *External_security_clause_kindContext) { +} + +// ExitExternal_security_clause_kind is called when production external_security_clause_kind is exited. +func (s *BaseGoogleSQLParserListener) ExitExternal_security_clause_kind(ctx *External_security_clause_kindContext) { +} + +// EnterProcedure_parameters is called when production procedure_parameters is entered. +func (s *BaseGoogleSQLParserListener) EnterProcedure_parameters(ctx *Procedure_parametersContext) {} + +// ExitProcedure_parameters is called when production procedure_parameters is exited. +func (s *BaseGoogleSQLParserListener) ExitProcedure_parameters(ctx *Procedure_parametersContext) {} + +// EnterProcedure_parameter is called when production procedure_parameter is entered. +func (s *BaseGoogleSQLParserListener) EnterProcedure_parameter(ctx *Procedure_parameterContext) {} + +// ExitProcedure_parameter is called when production procedure_parameter is exited. +func (s *BaseGoogleSQLParserListener) ExitProcedure_parameter(ctx *Procedure_parameterContext) {} + +// EnterProcedure_parameter_termination is called when production procedure_parameter_termination is entered. +func (s *BaseGoogleSQLParserListener) EnterProcedure_parameter_termination(ctx *Procedure_parameter_terminationContext) { +} + +// ExitProcedure_parameter_termination is called when production procedure_parameter_termination is exited. +func (s *BaseGoogleSQLParserListener) ExitProcedure_parameter_termination(ctx *Procedure_parameter_terminationContext) { +} + +// EnterOpt_procedure_parameter_mode is called when production opt_procedure_parameter_mode is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_procedure_parameter_mode(ctx *Opt_procedure_parameter_modeContext) { +} + +// ExitOpt_procedure_parameter_mode is called when production opt_procedure_parameter_mode is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_procedure_parameter_mode(ctx *Opt_procedure_parameter_modeContext) { +} + +// EnterCreate_function_statement is called when production create_function_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterCreate_function_statement(ctx *Create_function_statementContext) { +} + +// ExitCreate_function_statement is called when production create_function_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitCreate_function_statement(ctx *Create_function_statementContext) { +} + +// EnterOpt_determinism_level is called when production opt_determinism_level is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_determinism_level(ctx *Opt_determinism_levelContext) {} + +// ExitOpt_determinism_level is called when production opt_determinism_level is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_determinism_level(ctx *Opt_determinism_levelContext) {} + +// EnterOpt_sql_security_clause is called when production opt_sql_security_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_sql_security_clause(ctx *Opt_sql_security_clauseContext) { +} + +// ExitOpt_sql_security_clause is called when production opt_sql_security_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_sql_security_clause(ctx *Opt_sql_security_clauseContext) { +} + +// EnterSql_security_clause_kind is called when production sql_security_clause_kind is entered. +func (s *BaseGoogleSQLParserListener) EnterSql_security_clause_kind(ctx *Sql_security_clause_kindContext) { +} + +// ExitSql_security_clause_kind is called when production sql_security_clause_kind is exited. +func (s *BaseGoogleSQLParserListener) ExitSql_security_clause_kind(ctx *Sql_security_clause_kindContext) { +} + +// EnterAs_sql_function_body_or_string is called when production as_sql_function_body_or_string is entered. +func (s *BaseGoogleSQLParserListener) EnterAs_sql_function_body_or_string(ctx *As_sql_function_body_or_stringContext) { +} + +// ExitAs_sql_function_body_or_string is called when production as_sql_function_body_or_string is exited. +func (s *BaseGoogleSQLParserListener) ExitAs_sql_function_body_or_string(ctx *As_sql_function_body_or_stringContext) { +} + +// EnterSql_function_body is called when production sql_function_body is entered. +func (s *BaseGoogleSQLParserListener) EnterSql_function_body(ctx *Sql_function_bodyContext) {} + +// ExitSql_function_body is called when production sql_function_body is exited. +func (s *BaseGoogleSQLParserListener) ExitSql_function_body(ctx *Sql_function_bodyContext) {} + +// EnterUnordered_options_body is called when production unordered_options_body is entered. +func (s *BaseGoogleSQLParserListener) EnterUnordered_options_body(ctx *Unordered_options_bodyContext) { +} + +// ExitUnordered_options_body is called when production unordered_options_body is exited. +func (s *BaseGoogleSQLParserListener) ExitUnordered_options_body(ctx *Unordered_options_bodyContext) { +} + +// EnterOpt_language_or_remote_with_connection is called when production opt_language_or_remote_with_connection is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_language_or_remote_with_connection(ctx *Opt_language_or_remote_with_connectionContext) { +} + +// ExitOpt_language_or_remote_with_connection is called when production opt_language_or_remote_with_connection is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_language_or_remote_with_connection(ctx *Opt_language_or_remote_with_connectionContext) { +} + +// EnterLanguage is called when production language is entered. +func (s *BaseGoogleSQLParserListener) EnterLanguage(ctx *LanguageContext) {} + +// ExitLanguage is called when production language is exited. +func (s *BaseGoogleSQLParserListener) ExitLanguage(ctx *LanguageContext) {} + +// EnterRemote_with_connection_clause is called when production remote_with_connection_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterRemote_with_connection_clause(ctx *Remote_with_connection_clauseContext) { +} + +// ExitRemote_with_connection_clause is called when production remote_with_connection_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitRemote_with_connection_clause(ctx *Remote_with_connection_clauseContext) { +} + +// EnterWith_connection_clause is called when production with_connection_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterWith_connection_clause(ctx *With_connection_clauseContext) { +} + +// ExitWith_connection_clause is called when production with_connection_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitWith_connection_clause(ctx *With_connection_clauseContext) { +} + +// EnterOpt_function_returns is called when production opt_function_returns is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_function_returns(ctx *Opt_function_returnsContext) {} + +// ExitOpt_function_returns is called when production opt_function_returns is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_function_returns(ctx *Opt_function_returnsContext) {} + +// EnterOpt_returns is called when production opt_returns is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_returns(ctx *Opt_returnsContext) {} + +// ExitOpt_returns is called when production opt_returns is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_returns(ctx *Opt_returnsContext) {} + +// EnterFunction_declaration is called when production function_declaration is entered. +func (s *BaseGoogleSQLParserListener) EnterFunction_declaration(ctx *Function_declarationContext) {} + +// ExitFunction_declaration is called when production function_declaration is exited. +func (s *BaseGoogleSQLParserListener) ExitFunction_declaration(ctx *Function_declarationContext) {} + +// EnterFunction_parameters is called when production function_parameters is entered. +func (s *BaseGoogleSQLParserListener) EnterFunction_parameters(ctx *Function_parametersContext) {} + +// ExitFunction_parameters is called when production function_parameters is exited. +func (s *BaseGoogleSQLParserListener) ExitFunction_parameters(ctx *Function_parametersContext) {} + +// EnterFunction_parameter is called when production function_parameter is entered. +func (s *BaseGoogleSQLParserListener) EnterFunction_parameter(ctx *Function_parameterContext) {} + +// ExitFunction_parameter is called when production function_parameter is exited. +func (s *BaseGoogleSQLParserListener) ExitFunction_parameter(ctx *Function_parameterContext) {} + +// EnterOpt_not_aggregate is called when production opt_not_aggregate is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_not_aggregate(ctx *Opt_not_aggregateContext) {} + +// ExitOpt_not_aggregate is called when production opt_not_aggregate is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_not_aggregate(ctx *Opt_not_aggregateContext) {} + +// EnterOpt_default_expression is called when production opt_default_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_default_expression(ctx *Opt_default_expressionContext) { +} + +// ExitOpt_default_expression is called when production opt_default_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_default_expression(ctx *Opt_default_expressionContext) { +} + +// EnterType_or_tvf_schema is called when production type_or_tvf_schema is entered. +func (s *BaseGoogleSQLParserListener) EnterType_or_tvf_schema(ctx *Type_or_tvf_schemaContext) {} + +// ExitType_or_tvf_schema is called when production type_or_tvf_schema is exited. +func (s *BaseGoogleSQLParserListener) ExitType_or_tvf_schema(ctx *Type_or_tvf_schemaContext) {} + +// EnterTvf_schema is called when production tvf_schema is entered. +func (s *BaseGoogleSQLParserListener) EnterTvf_schema(ctx *Tvf_schemaContext) {} + +// ExitTvf_schema is called when production tvf_schema is exited. +func (s *BaseGoogleSQLParserListener) ExitTvf_schema(ctx *Tvf_schemaContext) {} + +// EnterTvf_schema_column is called when production tvf_schema_column is entered. +func (s *BaseGoogleSQLParserListener) EnterTvf_schema_column(ctx *Tvf_schema_columnContext) {} + +// ExitTvf_schema_column is called when production tvf_schema_column is exited. +func (s *BaseGoogleSQLParserListener) ExitTvf_schema_column(ctx *Tvf_schema_columnContext) {} + +// EnterTemplated_parameter_type is called when production templated_parameter_type is entered. +func (s *BaseGoogleSQLParserListener) EnterTemplated_parameter_type(ctx *Templated_parameter_typeContext) { +} + +// ExitTemplated_parameter_type is called when production templated_parameter_type is exited. +func (s *BaseGoogleSQLParserListener) ExitTemplated_parameter_type(ctx *Templated_parameter_typeContext) { +} + +// EnterTemplated_parameter_kind is called when production templated_parameter_kind is entered. +func (s *BaseGoogleSQLParserListener) EnterTemplated_parameter_kind(ctx *Templated_parameter_kindContext) { +} + +// ExitTemplated_parameter_kind is called when production templated_parameter_kind is exited. +func (s *BaseGoogleSQLParserListener) ExitTemplated_parameter_kind(ctx *Templated_parameter_kindContext) { +} + +// EnterOpt_aggregate is called when production opt_aggregate is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_aggregate(ctx *Opt_aggregateContext) {} + +// ExitOpt_aggregate is called when production opt_aggregate is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_aggregate(ctx *Opt_aggregateContext) {} + +// EnterCreate_database_statement is called when production create_database_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterCreate_database_statement(ctx *Create_database_statementContext) { +} + +// ExitCreate_database_statement is called when production create_database_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitCreate_database_statement(ctx *Create_database_statementContext) { +} + +// EnterCreate_connection_statement is called when production create_connection_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterCreate_connection_statement(ctx *Create_connection_statementContext) { +} + +// ExitCreate_connection_statement is called when production create_connection_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitCreate_connection_statement(ctx *Create_connection_statementContext) { +} + +// EnterCreate_constant_statement is called when production create_constant_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterCreate_constant_statement(ctx *Create_constant_statementContext) { +} + +// ExitCreate_constant_statement is called when production create_constant_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitCreate_constant_statement(ctx *Create_constant_statementContext) { +} + +// EnterOpt_or_replace is called when production opt_or_replace is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_or_replace(ctx *Opt_or_replaceContext) {} + +// ExitOpt_or_replace is called when production opt_or_replace is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_or_replace(ctx *Opt_or_replaceContext) {} + +// EnterOpt_create_scope is called when production opt_create_scope is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_create_scope(ctx *Opt_create_scopeContext) {} + +// ExitOpt_create_scope is called when production opt_create_scope is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_create_scope(ctx *Opt_create_scopeContext) {} + +// EnterRun_batch_statement is called when production run_batch_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterRun_batch_statement(ctx *Run_batch_statementContext) {} + +// ExitRun_batch_statement is called when production run_batch_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitRun_batch_statement(ctx *Run_batch_statementContext) {} + +// EnterAbort_batch_statement is called when production abort_batch_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterAbort_batch_statement(ctx *Abort_batch_statementContext) {} + +// ExitAbort_batch_statement is called when production abort_batch_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitAbort_batch_statement(ctx *Abort_batch_statementContext) {} + +// EnterStart_batch_statement is called when production start_batch_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterStart_batch_statement(ctx *Start_batch_statementContext) {} + +// ExitStart_batch_statement is called when production start_batch_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitStart_batch_statement(ctx *Start_batch_statementContext) {} + +// EnterRollback_statement is called when production rollback_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterRollback_statement(ctx *Rollback_statementContext) {} + +// ExitRollback_statement is called when production rollback_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitRollback_statement(ctx *Rollback_statementContext) {} + +// EnterCommit_statement is called when production commit_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterCommit_statement(ctx *Commit_statementContext) {} + +// ExitCommit_statement is called when production commit_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitCommit_statement(ctx *Commit_statementContext) {} + +// EnterSet_statement is called when production set_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterSet_statement(ctx *Set_statementContext) {} + +// ExitSet_statement is called when production set_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitSet_statement(ctx *Set_statementContext) {} + +// EnterIdentifier_list is called when production identifier_list is entered. +func (s *BaseGoogleSQLParserListener) EnterIdentifier_list(ctx *Identifier_listContext) {} + +// ExitIdentifier_list is called when production identifier_list is exited. +func (s *BaseGoogleSQLParserListener) ExitIdentifier_list(ctx *Identifier_listContext) {} + +// EnterBegin_statement is called when production begin_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterBegin_statement(ctx *Begin_statementContext) {} + +// ExitBegin_statement is called when production begin_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitBegin_statement(ctx *Begin_statementContext) {} + +// EnterBegin_transaction_keywords is called when production begin_transaction_keywords is entered. +func (s *BaseGoogleSQLParserListener) EnterBegin_transaction_keywords(ctx *Begin_transaction_keywordsContext) { +} + +// ExitBegin_transaction_keywords is called when production begin_transaction_keywords is exited. +func (s *BaseGoogleSQLParserListener) ExitBegin_transaction_keywords(ctx *Begin_transaction_keywordsContext) { +} + +// EnterTransaction_mode_list is called when production transaction_mode_list is entered. +func (s *BaseGoogleSQLParserListener) EnterTransaction_mode_list(ctx *Transaction_mode_listContext) {} + +// ExitTransaction_mode_list is called when production transaction_mode_list is exited. +func (s *BaseGoogleSQLParserListener) ExitTransaction_mode_list(ctx *Transaction_mode_listContext) {} + +// EnterTransaction_mode is called when production transaction_mode is entered. +func (s *BaseGoogleSQLParserListener) EnterTransaction_mode(ctx *Transaction_modeContext) {} + +// ExitTransaction_mode is called when production transaction_mode is exited. +func (s *BaseGoogleSQLParserListener) ExitTransaction_mode(ctx *Transaction_modeContext) {} + +// EnterTruncate_statement is called when production truncate_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterTruncate_statement(ctx *Truncate_statementContext) {} + +// ExitTruncate_statement is called when production truncate_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitTruncate_statement(ctx *Truncate_statementContext) {} + +// EnterMerge_statement is called when production merge_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterMerge_statement(ctx *Merge_statementContext) {} + +// ExitMerge_statement is called when production merge_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitMerge_statement(ctx *Merge_statementContext) {} + +// EnterMerge_source is called when production merge_source is entered. +func (s *BaseGoogleSQLParserListener) EnterMerge_source(ctx *Merge_sourceContext) {} + +// ExitMerge_source is called when production merge_source is exited. +func (s *BaseGoogleSQLParserListener) ExitMerge_source(ctx *Merge_sourceContext) {} + +// EnterMerge_when_clause is called when production merge_when_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterMerge_when_clause(ctx *Merge_when_clauseContext) {} + +// ExitMerge_when_clause is called when production merge_when_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitMerge_when_clause(ctx *Merge_when_clauseContext) {} + +// EnterMerge_action is called when production merge_action is entered. +func (s *BaseGoogleSQLParserListener) EnterMerge_action(ctx *Merge_actionContext) {} + +// ExitMerge_action is called when production merge_action is exited. +func (s *BaseGoogleSQLParserListener) ExitMerge_action(ctx *Merge_actionContext) {} + +// EnterMerge_insert_value_list_or_source_row is called when production merge_insert_value_list_or_source_row is entered. +func (s *BaseGoogleSQLParserListener) EnterMerge_insert_value_list_or_source_row(ctx *Merge_insert_value_list_or_source_rowContext) { +} + +// ExitMerge_insert_value_list_or_source_row is called when production merge_insert_value_list_or_source_row is exited. +func (s *BaseGoogleSQLParserListener) ExitMerge_insert_value_list_or_source_row(ctx *Merge_insert_value_list_or_source_rowContext) { +} + +// EnterBy_target is called when production by_target is entered. +func (s *BaseGoogleSQLParserListener) EnterBy_target(ctx *By_targetContext) {} + +// ExitBy_target is called when production by_target is exited. +func (s *BaseGoogleSQLParserListener) ExitBy_target(ctx *By_targetContext) {} + +// EnterOpt_and_expression is called when production opt_and_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_and_expression(ctx *Opt_and_expressionContext) {} + +// ExitOpt_and_expression is called when production opt_and_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_and_expression(ctx *Opt_and_expressionContext) {} + +// EnterStatement_level_hint is called when production statement_level_hint is entered. +func (s *BaseGoogleSQLParserListener) EnterStatement_level_hint(ctx *Statement_level_hintContext) {} + +// ExitStatement_level_hint is called when production statement_level_hint is exited. +func (s *BaseGoogleSQLParserListener) ExitStatement_level_hint(ctx *Statement_level_hintContext) {} + +// EnterQuery_statement is called when production query_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterQuery_statement(ctx *Query_statementContext) {} + +// ExitQuery_statement is called when production query_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitQuery_statement(ctx *Query_statementContext) {} + +// EnterDml_statement is called when production dml_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterDml_statement(ctx *Dml_statementContext) {} + +// ExitDml_statement is called when production dml_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitDml_statement(ctx *Dml_statementContext) {} + +// EnterUpdate_statement is called when production update_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterUpdate_statement(ctx *Update_statementContext) {} + +// ExitUpdate_statement is called when production update_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitUpdate_statement(ctx *Update_statementContext) {} + +// EnterDelete_statement is called when production delete_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterDelete_statement(ctx *Delete_statementContext) {} + +// ExitDelete_statement is called when production delete_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitDelete_statement(ctx *Delete_statementContext) {} + +// EnterInsert_statement is called when production insert_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterInsert_statement(ctx *Insert_statementContext) {} + +// ExitInsert_statement is called when production insert_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitInsert_statement(ctx *Insert_statementContext) {} + +// EnterOn_conflict_clause is called when production on_conflict_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterOn_conflict_clause(ctx *On_conflict_clauseContext) {} + +// ExitOn_conflict_clause is called when production on_conflict_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitOn_conflict_clause(ctx *On_conflict_clauseContext) {} + +// EnterOpt_where_expression is called when production opt_where_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_where_expression(ctx *Opt_where_expressionContext) {} + +// ExitOpt_where_expression is called when production opt_where_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_where_expression(ctx *Opt_where_expressionContext) {} + +// EnterOpt_conflict_target is called when production opt_conflict_target is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_conflict_target(ctx *Opt_conflict_targetContext) {} + +// ExitOpt_conflict_target is called when production opt_conflict_target is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_conflict_target(ctx *Opt_conflict_targetContext) {} + +// EnterUpdate_item_list is called when production update_item_list is entered. +func (s *BaseGoogleSQLParserListener) EnterUpdate_item_list(ctx *Update_item_listContext) {} + +// ExitUpdate_item_list is called when production update_item_list is exited. +func (s *BaseGoogleSQLParserListener) ExitUpdate_item_list(ctx *Update_item_listContext) {} + +// EnterUpdate_item is called when production update_item is entered. +func (s *BaseGoogleSQLParserListener) EnterUpdate_item(ctx *Update_itemContext) {} + +// ExitUpdate_item is called when production update_item is exited. +func (s *BaseGoogleSQLParserListener) ExitUpdate_item(ctx *Update_itemContext) {} + +// EnterUpdate_set_value is called when production update_set_value is entered. +func (s *BaseGoogleSQLParserListener) EnterUpdate_set_value(ctx *Update_set_valueContext) {} + +// ExitUpdate_set_value is called when production update_set_value is exited. +func (s *BaseGoogleSQLParserListener) ExitUpdate_set_value(ctx *Update_set_valueContext) {} + +// EnterNested_dml_statement is called when production nested_dml_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterNested_dml_statement(ctx *Nested_dml_statementContext) {} + +// ExitNested_dml_statement is called when production nested_dml_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitNested_dml_statement(ctx *Nested_dml_statementContext) {} + +// EnterInsert_values_list_or_table_clause is called when production insert_values_list_or_table_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterInsert_values_list_or_table_clause(ctx *Insert_values_list_or_table_clauseContext) { +} + +// ExitInsert_values_list_or_table_clause is called when production insert_values_list_or_table_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitInsert_values_list_or_table_clause(ctx *Insert_values_list_or_table_clauseContext) { +} + +// EnterTable_clause_unreversed is called when production table_clause_unreversed is entered. +func (s *BaseGoogleSQLParserListener) EnterTable_clause_unreversed(ctx *Table_clause_unreversedContext) { +} + +// ExitTable_clause_unreversed is called when production table_clause_unreversed is exited. +func (s *BaseGoogleSQLParserListener) ExitTable_clause_unreversed(ctx *Table_clause_unreversedContext) { +} + +// EnterTable_clause_no_keyword is called when production table_clause_no_keyword is entered. +func (s *BaseGoogleSQLParserListener) EnterTable_clause_no_keyword(ctx *Table_clause_no_keywordContext) { +} + +// ExitTable_clause_no_keyword is called when production table_clause_no_keyword is exited. +func (s *BaseGoogleSQLParserListener) ExitTable_clause_no_keyword(ctx *Table_clause_no_keywordContext) { +} + +// EnterOpt_returning_clause is called when production opt_returning_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_returning_clause(ctx *Opt_returning_clauseContext) {} + +// ExitOpt_returning_clause is called when production opt_returning_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_returning_clause(ctx *Opt_returning_clauseContext) {} + +// EnterOpt_assert_rows_modified is called when production opt_assert_rows_modified is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_assert_rows_modified(ctx *Opt_assert_rows_modifiedContext) { +} + +// ExitOpt_assert_rows_modified is called when production opt_assert_rows_modified is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_assert_rows_modified(ctx *Opt_assert_rows_modifiedContext) { +} + +// EnterInsert_values_or_query is called when production insert_values_or_query is entered. +func (s *BaseGoogleSQLParserListener) EnterInsert_values_or_query(ctx *Insert_values_or_queryContext) { +} + +// ExitInsert_values_or_query is called when production insert_values_or_query is exited. +func (s *BaseGoogleSQLParserListener) ExitInsert_values_or_query(ctx *Insert_values_or_queryContext) { +} + +// EnterInsert_values_list is called when production insert_values_list is entered. +func (s *BaseGoogleSQLParserListener) EnterInsert_values_list(ctx *Insert_values_listContext) {} + +// ExitInsert_values_list is called when production insert_values_list is exited. +func (s *BaseGoogleSQLParserListener) ExitInsert_values_list(ctx *Insert_values_listContext) {} + +// EnterInsert_values_row is called when production insert_values_row is entered. +func (s *BaseGoogleSQLParserListener) EnterInsert_values_row(ctx *Insert_values_rowContext) {} + +// ExitInsert_values_row is called when production insert_values_row is exited. +func (s *BaseGoogleSQLParserListener) ExitInsert_values_row(ctx *Insert_values_rowContext) {} + +// EnterExpression_or_default is called when production expression_or_default is entered. +func (s *BaseGoogleSQLParserListener) EnterExpression_or_default(ctx *Expression_or_defaultContext) {} + +// ExitExpression_or_default is called when production expression_or_default is exited. +func (s *BaseGoogleSQLParserListener) ExitExpression_or_default(ctx *Expression_or_defaultContext) {} + +// EnterInsert_statement_prefix is called when production insert_statement_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterInsert_statement_prefix(ctx *Insert_statement_prefixContext) { +} + +// ExitInsert_statement_prefix is called when production insert_statement_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitInsert_statement_prefix(ctx *Insert_statement_prefixContext) { +} + +// EnterMaybe_dashed_generalized_path_expression is called when production maybe_dashed_generalized_path_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterMaybe_dashed_generalized_path_expression(ctx *Maybe_dashed_generalized_path_expressionContext) { +} + +// ExitMaybe_dashed_generalized_path_expression is called when production maybe_dashed_generalized_path_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitMaybe_dashed_generalized_path_expression(ctx *Maybe_dashed_generalized_path_expressionContext) { +} + +// EnterOpt_into is called when production opt_into is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_into(ctx *Opt_intoContext) {} + +// ExitOpt_into is called when production opt_into is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_into(ctx *Opt_intoContext) {} + +// EnterOpt_or_ignore_replace_update is called when production opt_or_ignore_replace_update is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_or_ignore_replace_update(ctx *Opt_or_ignore_replace_updateContext) { +} + +// ExitOpt_or_ignore_replace_update is called when production opt_or_ignore_replace_update is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_or_ignore_replace_update(ctx *Opt_or_ignore_replace_updateContext) { +} + +// EnterAlter_statement is called when production alter_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterAlter_statement(ctx *Alter_statementContext) {} + +// ExitAlter_statement is called when production alter_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitAlter_statement(ctx *Alter_statementContext) {} + +// EnterAnalyze_statement is called when production analyze_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterAnalyze_statement(ctx *Analyze_statementContext) {} + +// ExitAnalyze_statement is called when production analyze_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitAnalyze_statement(ctx *Analyze_statementContext) {} + +// EnterAssert_statement is called when production assert_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterAssert_statement(ctx *Assert_statementContext) {} + +// ExitAssert_statement is called when production assert_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitAssert_statement(ctx *Assert_statementContext) {} + +// EnterAux_load_data_statement is called when production aux_load_data_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterAux_load_data_statement(ctx *Aux_load_data_statementContext) { +} + +// ExitAux_load_data_statement is called when production aux_load_data_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitAux_load_data_statement(ctx *Aux_load_data_statementContext) { +} + +// EnterClone_data_statement is called when production clone_data_statement is entered. +func (s *BaseGoogleSQLParserListener) EnterClone_data_statement(ctx *Clone_data_statementContext) {} + +// ExitClone_data_statement is called when production clone_data_statement is exited. +func (s *BaseGoogleSQLParserListener) ExitClone_data_statement(ctx *Clone_data_statementContext) {} + +// EnterClone_data_source_list is called when production clone_data_source_list is entered. +func (s *BaseGoogleSQLParserListener) EnterClone_data_source_list(ctx *Clone_data_source_listContext) { +} + +// ExitClone_data_source_list is called when production clone_data_source_list is exited. +func (s *BaseGoogleSQLParserListener) ExitClone_data_source_list(ctx *Clone_data_source_listContext) { +} + +// EnterClone_data_source is called when production clone_data_source is entered. +func (s *BaseGoogleSQLParserListener) EnterClone_data_source(ctx *Clone_data_sourceContext) {} + +// ExitClone_data_source is called when production clone_data_source is exited. +func (s *BaseGoogleSQLParserListener) ExitClone_data_source(ctx *Clone_data_sourceContext) {} + +// EnterOpt_external_table_with_clauses is called when production opt_external_table_with_clauses is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_external_table_with_clauses(ctx *Opt_external_table_with_clausesContext) { +} + +// ExitOpt_external_table_with_clauses is called when production opt_external_table_with_clauses is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_external_table_with_clauses(ctx *Opt_external_table_with_clausesContext) { +} + +// EnterWith_partition_columns_clause is called when production with_partition_columns_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterWith_partition_columns_clause(ctx *With_partition_columns_clauseContext) { +} + +// ExitWith_partition_columns_clause is called when production with_partition_columns_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitWith_partition_columns_clause(ctx *With_partition_columns_clauseContext) { +} + +// EnterAux_load_data_from_files_options_list is called when production aux_load_data_from_files_options_list is entered. +func (s *BaseGoogleSQLParserListener) EnterAux_load_data_from_files_options_list(ctx *Aux_load_data_from_files_options_listContext) { +} + +// ExitAux_load_data_from_files_options_list is called when production aux_load_data_from_files_options_list is exited. +func (s *BaseGoogleSQLParserListener) ExitAux_load_data_from_files_options_list(ctx *Aux_load_data_from_files_options_listContext) { +} + +// EnterCluster_by_clause_prefix_no_hint is called when production cluster_by_clause_prefix_no_hint is entered. +func (s *BaseGoogleSQLParserListener) EnterCluster_by_clause_prefix_no_hint(ctx *Cluster_by_clause_prefix_no_hintContext) { +} + +// ExitCluster_by_clause_prefix_no_hint is called when production cluster_by_clause_prefix_no_hint is exited. +func (s *BaseGoogleSQLParserListener) ExitCluster_by_clause_prefix_no_hint(ctx *Cluster_by_clause_prefix_no_hintContext) { +} + +// EnterLoad_data_partitions_clause is called when production load_data_partitions_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterLoad_data_partitions_clause(ctx *Load_data_partitions_clauseContext) { +} + +// ExitLoad_data_partitions_clause is called when production load_data_partitions_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitLoad_data_partitions_clause(ctx *Load_data_partitions_clauseContext) { +} + +// EnterMaybe_dashed_path_expression_with_scope is called when production maybe_dashed_path_expression_with_scope is entered. +func (s *BaseGoogleSQLParserListener) EnterMaybe_dashed_path_expression_with_scope(ctx *Maybe_dashed_path_expression_with_scopeContext) { +} + +// ExitMaybe_dashed_path_expression_with_scope is called when production maybe_dashed_path_expression_with_scope is exited. +func (s *BaseGoogleSQLParserListener) ExitMaybe_dashed_path_expression_with_scope(ctx *Maybe_dashed_path_expression_with_scopeContext) { +} + +// EnterTable_element_list is called when production table_element_list is entered. +func (s *BaseGoogleSQLParserListener) EnterTable_element_list(ctx *Table_element_listContext) {} + +// ExitTable_element_list is called when production table_element_list is exited. +func (s *BaseGoogleSQLParserListener) ExitTable_element_list(ctx *Table_element_listContext) {} + +// EnterTable_element is called when production table_element is entered. +func (s *BaseGoogleSQLParserListener) EnterTable_element(ctx *Table_elementContext) {} + +// ExitTable_element is called when production table_element is exited. +func (s *BaseGoogleSQLParserListener) ExitTable_element(ctx *Table_elementContext) {} + +// EnterTable_constraint_definition is called when production table_constraint_definition is entered. +func (s *BaseGoogleSQLParserListener) EnterTable_constraint_definition(ctx *Table_constraint_definitionContext) { +} + +// ExitTable_constraint_definition is called when production table_constraint_definition is exited. +func (s *BaseGoogleSQLParserListener) ExitTable_constraint_definition(ctx *Table_constraint_definitionContext) { +} + +// EnterAppend_or_overwrite is called when production append_or_overwrite is entered. +func (s *BaseGoogleSQLParserListener) EnterAppend_or_overwrite(ctx *Append_or_overwriteContext) {} + +// ExitAppend_or_overwrite is called when production append_or_overwrite is exited. +func (s *BaseGoogleSQLParserListener) ExitAppend_or_overwrite(ctx *Append_or_overwriteContext) {} + +// EnterOpt_description is called when production opt_description is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_description(ctx *Opt_descriptionContext) {} + +// ExitOpt_description is called when production opt_description is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_description(ctx *Opt_descriptionContext) {} + +// EnterTable_and_column_info_list is called when production table_and_column_info_list is entered. +func (s *BaseGoogleSQLParserListener) EnterTable_and_column_info_list(ctx *Table_and_column_info_listContext) { +} + +// ExitTable_and_column_info_list is called when production table_and_column_info_list is exited. +func (s *BaseGoogleSQLParserListener) ExitTable_and_column_info_list(ctx *Table_and_column_info_listContext) { +} + +// EnterTable_and_column_info is called when production table_and_column_info is entered. +func (s *BaseGoogleSQLParserListener) EnterTable_and_column_info(ctx *Table_and_column_infoContext) {} + +// ExitTable_and_column_info is called when production table_and_column_info is exited. +func (s *BaseGoogleSQLParserListener) ExitTable_and_column_info(ctx *Table_and_column_infoContext) {} + +// EnterRow_access_policy_alter_action_list is called when production row_access_policy_alter_action_list is entered. +func (s *BaseGoogleSQLParserListener) EnterRow_access_policy_alter_action_list(ctx *Row_access_policy_alter_action_listContext) { +} + +// ExitRow_access_policy_alter_action_list is called when production row_access_policy_alter_action_list is exited. +func (s *BaseGoogleSQLParserListener) ExitRow_access_policy_alter_action_list(ctx *Row_access_policy_alter_action_listContext) { +} + +// EnterRow_access_policy_alter_action is called when production row_access_policy_alter_action is entered. +func (s *BaseGoogleSQLParserListener) EnterRow_access_policy_alter_action(ctx *Row_access_policy_alter_actionContext) { +} + +// ExitRow_access_policy_alter_action is called when production row_access_policy_alter_action is exited. +func (s *BaseGoogleSQLParserListener) ExitRow_access_policy_alter_action(ctx *Row_access_policy_alter_actionContext) { +} + +// EnterGrant_to_clause is called when production grant_to_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterGrant_to_clause(ctx *Grant_to_clauseContext) {} + +// ExitGrant_to_clause is called when production grant_to_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitGrant_to_clause(ctx *Grant_to_clauseContext) {} + +// EnterGrantee_list is called when production grantee_list is entered. +func (s *BaseGoogleSQLParserListener) EnterGrantee_list(ctx *Grantee_listContext) {} + +// ExitGrantee_list is called when production grantee_list is exited. +func (s *BaseGoogleSQLParserListener) ExitGrantee_list(ctx *Grantee_listContext) {} + +// EnterPrivilege_list is called when production privilege_list is entered. +func (s *BaseGoogleSQLParserListener) EnterPrivilege_list(ctx *Privilege_listContext) {} + +// ExitPrivilege_list is called when production privilege_list is exited. +func (s *BaseGoogleSQLParserListener) ExitPrivilege_list(ctx *Privilege_listContext) {} + +// EnterPrivilege is called when production privilege is entered. +func (s *BaseGoogleSQLParserListener) EnterPrivilege(ctx *PrivilegeContext) {} + +// ExitPrivilege is called when production privilege is exited. +func (s *BaseGoogleSQLParserListener) ExitPrivilege(ctx *PrivilegeContext) {} + +// EnterPath_expression_list_with_parens is called when production path_expression_list_with_parens is entered. +func (s *BaseGoogleSQLParserListener) EnterPath_expression_list_with_parens(ctx *Path_expression_list_with_parensContext) { +} + +// ExitPath_expression_list_with_parens is called when production path_expression_list_with_parens is exited. +func (s *BaseGoogleSQLParserListener) ExitPath_expression_list_with_parens(ctx *Path_expression_list_with_parensContext) { +} + +// EnterPrivilege_name is called when production privilege_name is entered. +func (s *BaseGoogleSQLParserListener) EnterPrivilege_name(ctx *Privilege_nameContext) {} + +// ExitPrivilege_name is called when production privilege_name is exited. +func (s *BaseGoogleSQLParserListener) ExitPrivilege_name(ctx *Privilege_nameContext) {} + +// EnterGeneric_entity_type is called when production generic_entity_type is entered. +func (s *BaseGoogleSQLParserListener) EnterGeneric_entity_type(ctx *Generic_entity_typeContext) {} + +// ExitGeneric_entity_type is called when production generic_entity_type is exited. +func (s *BaseGoogleSQLParserListener) ExitGeneric_entity_type(ctx *Generic_entity_typeContext) {} + +// EnterGeneric_entity_type_unchecked is called when production generic_entity_type_unchecked is entered. +func (s *BaseGoogleSQLParserListener) EnterGeneric_entity_type_unchecked(ctx *Generic_entity_type_uncheckedContext) { +} + +// ExitGeneric_entity_type_unchecked is called when production generic_entity_type_unchecked is exited. +func (s *BaseGoogleSQLParserListener) ExitGeneric_entity_type_unchecked(ctx *Generic_entity_type_uncheckedContext) { +} + +// EnterSchema_object_kind is called when production schema_object_kind is entered. +func (s *BaseGoogleSQLParserListener) EnterSchema_object_kind(ctx *Schema_object_kindContext) {} + +// ExitSchema_object_kind is called when production schema_object_kind is exited. +func (s *BaseGoogleSQLParserListener) ExitSchema_object_kind(ctx *Schema_object_kindContext) {} + +// EnterAlter_action_list is called when production alter_action_list is entered. +func (s *BaseGoogleSQLParserListener) EnterAlter_action_list(ctx *Alter_action_listContext) {} + +// ExitAlter_action_list is called when production alter_action_list is exited. +func (s *BaseGoogleSQLParserListener) ExitAlter_action_list(ctx *Alter_action_listContext) {} + +// EnterAlter_action is called when production alter_action is entered. +func (s *BaseGoogleSQLParserListener) EnterAlter_action(ctx *Alter_actionContext) {} + +// ExitAlter_action is called when production alter_action is exited. +func (s *BaseGoogleSQLParserListener) ExitAlter_action(ctx *Alter_actionContext) {} + +// EnterSpanner_set_on_delete_action is called when production spanner_set_on_delete_action is entered. +func (s *BaseGoogleSQLParserListener) EnterSpanner_set_on_delete_action(ctx *Spanner_set_on_delete_actionContext) { +} + +// ExitSpanner_set_on_delete_action is called when production spanner_set_on_delete_action is exited. +func (s *BaseGoogleSQLParserListener) ExitSpanner_set_on_delete_action(ctx *Spanner_set_on_delete_actionContext) { +} + +// EnterSpanner_alter_column_action is called when production spanner_alter_column_action is entered. +func (s *BaseGoogleSQLParserListener) EnterSpanner_alter_column_action(ctx *Spanner_alter_column_actionContext) { +} + +// ExitSpanner_alter_column_action is called when production spanner_alter_column_action is exited. +func (s *BaseGoogleSQLParserListener) ExitSpanner_alter_column_action(ctx *Spanner_alter_column_actionContext) { +} + +// EnterSpanner_generated_or_default is called when production spanner_generated_or_default is entered. +func (s *BaseGoogleSQLParserListener) EnterSpanner_generated_or_default(ctx *Spanner_generated_or_defaultContext) { +} + +// ExitSpanner_generated_or_default is called when production spanner_generated_or_default is exited. +func (s *BaseGoogleSQLParserListener) ExitSpanner_generated_or_default(ctx *Spanner_generated_or_defaultContext) { +} + +// EnterGeneric_sub_entity_type is called when production generic_sub_entity_type is entered. +func (s *BaseGoogleSQLParserListener) EnterGeneric_sub_entity_type(ctx *Generic_sub_entity_typeContext) { +} + +// ExitGeneric_sub_entity_type is called when production generic_sub_entity_type is exited. +func (s *BaseGoogleSQLParserListener) ExitGeneric_sub_entity_type(ctx *Generic_sub_entity_typeContext) { +} + +// EnterSub_entity_type_identifier is called when production sub_entity_type_identifier is entered. +func (s *BaseGoogleSQLParserListener) EnterSub_entity_type_identifier(ctx *Sub_entity_type_identifierContext) { +} + +// ExitSub_entity_type_identifier is called when production sub_entity_type_identifier is exited. +func (s *BaseGoogleSQLParserListener) ExitSub_entity_type_identifier(ctx *Sub_entity_type_identifierContext) { +} + +// EnterFill_using_expression is called when production fill_using_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterFill_using_expression(ctx *Fill_using_expressionContext) {} + +// ExitFill_using_expression is called when production fill_using_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitFill_using_expression(ctx *Fill_using_expressionContext) {} + +// EnterColumn_position is called when production column_position is entered. +func (s *BaseGoogleSQLParserListener) EnterColumn_position(ctx *Column_positionContext) {} + +// ExitColumn_position is called when production column_position is exited. +func (s *BaseGoogleSQLParserListener) ExitColumn_position(ctx *Column_positionContext) {} + +// EnterTable_column_definition is called when production table_column_definition is entered. +func (s *BaseGoogleSQLParserListener) EnterTable_column_definition(ctx *Table_column_definitionContext) { +} + +// ExitTable_column_definition is called when production table_column_definition is exited. +func (s *BaseGoogleSQLParserListener) ExitTable_column_definition(ctx *Table_column_definitionContext) { +} + +// EnterColumn_attributes is called when production column_attributes is entered. +func (s *BaseGoogleSQLParserListener) EnterColumn_attributes(ctx *Column_attributesContext) {} + +// ExitColumn_attributes is called when production column_attributes is exited. +func (s *BaseGoogleSQLParserListener) ExitColumn_attributes(ctx *Column_attributesContext) {} + +// EnterColumn_attribute is called when production column_attribute is entered. +func (s *BaseGoogleSQLParserListener) EnterColumn_attribute(ctx *Column_attributeContext) {} + +// ExitColumn_attribute is called when production column_attribute is exited. +func (s *BaseGoogleSQLParserListener) ExitColumn_attribute(ctx *Column_attributeContext) {} + +// EnterPrimary_key_column_attribute is called when production primary_key_column_attribute is entered. +func (s *BaseGoogleSQLParserListener) EnterPrimary_key_column_attribute(ctx *Primary_key_column_attributeContext) { +} + +// ExitPrimary_key_column_attribute is called when production primary_key_column_attribute is exited. +func (s *BaseGoogleSQLParserListener) ExitPrimary_key_column_attribute(ctx *Primary_key_column_attributeContext) { +} + +// EnterForeign_key_column_attribute is called when production foreign_key_column_attribute is entered. +func (s *BaseGoogleSQLParserListener) EnterForeign_key_column_attribute(ctx *Foreign_key_column_attributeContext) { +} + +// ExitForeign_key_column_attribute is called when production foreign_key_column_attribute is exited. +func (s *BaseGoogleSQLParserListener) ExitForeign_key_column_attribute(ctx *Foreign_key_column_attributeContext) { +} + +// EnterHidden_column_attribute is called when production hidden_column_attribute is entered. +func (s *BaseGoogleSQLParserListener) EnterHidden_column_attribute(ctx *Hidden_column_attributeContext) { +} + +// ExitHidden_column_attribute is called when production hidden_column_attribute is exited. +func (s *BaseGoogleSQLParserListener) ExitHidden_column_attribute(ctx *Hidden_column_attributeContext) { +} + +// EnterOpt_constraint_identity is called when production opt_constraint_identity is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_constraint_identity(ctx *Opt_constraint_identityContext) { +} + +// ExitOpt_constraint_identity is called when production opt_constraint_identity is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_constraint_identity(ctx *Opt_constraint_identityContext) { +} + +// EnterTable_column_schema is called when production table_column_schema is entered. +func (s *BaseGoogleSQLParserListener) EnterTable_column_schema(ctx *Table_column_schemaContext) {} + +// ExitTable_column_schema is called when production table_column_schema is exited. +func (s *BaseGoogleSQLParserListener) ExitTable_column_schema(ctx *Table_column_schemaContext) {} + +// EnterOpt_column_info is called when production opt_column_info is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_column_info(ctx *Opt_column_infoContext) {} + +// ExitOpt_column_info is called when production opt_column_info is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_column_info(ctx *Opt_column_infoContext) {} + +// EnterInvalid_generated_column is called when production invalid_generated_column is entered. +func (s *BaseGoogleSQLParserListener) EnterInvalid_generated_column(ctx *Invalid_generated_columnContext) { +} + +// ExitInvalid_generated_column is called when production invalid_generated_column is exited. +func (s *BaseGoogleSQLParserListener) ExitInvalid_generated_column(ctx *Invalid_generated_columnContext) { +} + +// EnterInvalid_default_column is called when production invalid_default_column is entered. +func (s *BaseGoogleSQLParserListener) EnterInvalid_default_column(ctx *Invalid_default_columnContext) { +} + +// ExitInvalid_default_column is called when production invalid_default_column is exited. +func (s *BaseGoogleSQLParserListener) ExitInvalid_default_column(ctx *Invalid_default_columnContext) { +} + +// EnterDefault_column_info is called when production default_column_info is entered. +func (s *BaseGoogleSQLParserListener) EnterDefault_column_info(ctx *Default_column_infoContext) {} + +// ExitDefault_column_info is called when production default_column_info is exited. +func (s *BaseGoogleSQLParserListener) ExitDefault_column_info(ctx *Default_column_infoContext) {} + +// EnterGenerated_column_info is called when production generated_column_info is entered. +func (s *BaseGoogleSQLParserListener) EnterGenerated_column_info(ctx *Generated_column_infoContext) {} + +// ExitGenerated_column_info is called when production generated_column_info is exited. +func (s *BaseGoogleSQLParserListener) ExitGenerated_column_info(ctx *Generated_column_infoContext) {} + +// EnterIdentity_column_info is called when production identity_column_info is entered. +func (s *BaseGoogleSQLParserListener) EnterIdentity_column_info(ctx *Identity_column_infoContext) {} + +// ExitIdentity_column_info is called when production identity_column_info is exited. +func (s *BaseGoogleSQLParserListener) ExitIdentity_column_info(ctx *Identity_column_infoContext) {} + +// EnterOpt_start_with is called when production opt_start_with is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_start_with(ctx *Opt_start_withContext) {} + +// ExitOpt_start_with is called when production opt_start_with is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_start_with(ctx *Opt_start_withContext) {} + +// EnterOpt_increment_by is called when production opt_increment_by is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_increment_by(ctx *Opt_increment_byContext) {} + +// ExitOpt_increment_by is called when production opt_increment_by is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_increment_by(ctx *Opt_increment_byContext) {} + +// EnterOpt_maxvalue is called when production opt_maxvalue is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_maxvalue(ctx *Opt_maxvalueContext) {} + +// ExitOpt_maxvalue is called when production opt_maxvalue is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_maxvalue(ctx *Opt_maxvalueContext) {} + +// EnterOpt_minvalue is called when production opt_minvalue is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_minvalue(ctx *Opt_minvalueContext) {} + +// ExitOpt_minvalue is called when production opt_minvalue is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_minvalue(ctx *Opt_minvalueContext) {} + +// EnterOpt_cycle is called when production opt_cycle is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_cycle(ctx *Opt_cycleContext) {} + +// ExitOpt_cycle is called when production opt_cycle is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_cycle(ctx *Opt_cycleContext) {} + +// EnterSigned_numeric_literal is called when production signed_numeric_literal is entered. +func (s *BaseGoogleSQLParserListener) EnterSigned_numeric_literal(ctx *Signed_numeric_literalContext) { +} + +// ExitSigned_numeric_literal is called when production signed_numeric_literal is exited. +func (s *BaseGoogleSQLParserListener) ExitSigned_numeric_literal(ctx *Signed_numeric_literalContext) { +} + +// EnterStored_mode is called when production stored_mode is entered. +func (s *BaseGoogleSQLParserListener) EnterStored_mode(ctx *Stored_modeContext) {} + +// ExitStored_mode is called when production stored_mode is exited. +func (s *BaseGoogleSQLParserListener) ExitStored_mode(ctx *Stored_modeContext) {} + +// EnterGenerated_mode is called when production generated_mode is entered. +func (s *BaseGoogleSQLParserListener) EnterGenerated_mode(ctx *Generated_modeContext) {} + +// ExitGenerated_mode is called when production generated_mode is exited. +func (s *BaseGoogleSQLParserListener) ExitGenerated_mode(ctx *Generated_modeContext) {} + +// EnterColumn_schema_inner is called when production column_schema_inner is entered. +func (s *BaseGoogleSQLParserListener) EnterColumn_schema_inner(ctx *Column_schema_innerContext) {} + +// ExitColumn_schema_inner is called when production column_schema_inner is exited. +func (s *BaseGoogleSQLParserListener) ExitColumn_schema_inner(ctx *Column_schema_innerContext) {} + +// EnterRaw_column_schema_inner is called when production raw_column_schema_inner is entered. +func (s *BaseGoogleSQLParserListener) EnterRaw_column_schema_inner(ctx *Raw_column_schema_innerContext) { +} + +// ExitRaw_column_schema_inner is called when production raw_column_schema_inner is exited. +func (s *BaseGoogleSQLParserListener) ExitRaw_column_schema_inner(ctx *Raw_column_schema_innerContext) { +} + +// EnterRange_column_schema_inner is called when production range_column_schema_inner is entered. +func (s *BaseGoogleSQLParserListener) EnterRange_column_schema_inner(ctx *Range_column_schema_innerContext) { +} + +// ExitRange_column_schema_inner is called when production range_column_schema_inner is exited. +func (s *BaseGoogleSQLParserListener) ExitRange_column_schema_inner(ctx *Range_column_schema_innerContext) { +} + +// EnterStruct_column_schema_inner is called when production struct_column_schema_inner is entered. +func (s *BaseGoogleSQLParserListener) EnterStruct_column_schema_inner(ctx *Struct_column_schema_innerContext) { +} + +// ExitStruct_column_schema_inner is called when production struct_column_schema_inner is exited. +func (s *BaseGoogleSQLParserListener) ExitStruct_column_schema_inner(ctx *Struct_column_schema_innerContext) { +} + +// EnterStruct_column_field is called when production struct_column_field is entered. +func (s *BaseGoogleSQLParserListener) EnterStruct_column_field(ctx *Struct_column_fieldContext) {} + +// ExitStruct_column_field is called when production struct_column_field is exited. +func (s *BaseGoogleSQLParserListener) ExitStruct_column_field(ctx *Struct_column_fieldContext) {} + +// EnterSimple_column_schema_inner is called when production simple_column_schema_inner is entered. +func (s *BaseGoogleSQLParserListener) EnterSimple_column_schema_inner(ctx *Simple_column_schema_innerContext) { +} + +// ExitSimple_column_schema_inner is called when production simple_column_schema_inner is exited. +func (s *BaseGoogleSQLParserListener) ExitSimple_column_schema_inner(ctx *Simple_column_schema_innerContext) { +} + +// EnterArray_column_schema_inner is called when production array_column_schema_inner is entered. +func (s *BaseGoogleSQLParserListener) EnterArray_column_schema_inner(ctx *Array_column_schema_innerContext) { +} + +// ExitArray_column_schema_inner is called when production array_column_schema_inner is exited. +func (s *BaseGoogleSQLParserListener) ExitArray_column_schema_inner(ctx *Array_column_schema_innerContext) { +} + +// EnterField_schema is called when production field_schema is entered. +func (s *BaseGoogleSQLParserListener) EnterField_schema(ctx *Field_schemaContext) {} + +// ExitField_schema is called when production field_schema is exited. +func (s *BaseGoogleSQLParserListener) ExitField_schema(ctx *Field_schemaContext) {} + +// EnterOpt_field_attributes is called when production opt_field_attributes is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_field_attributes(ctx *Opt_field_attributesContext) {} + +// ExitOpt_field_attributes is called when production opt_field_attributes is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_field_attributes(ctx *Opt_field_attributesContext) {} + +// EnterNot_null_column_attribute is called when production not_null_column_attribute is entered. +func (s *BaseGoogleSQLParserListener) EnterNot_null_column_attribute(ctx *Not_null_column_attributeContext) { +} + +// ExitNot_null_column_attribute is called when production not_null_column_attribute is exited. +func (s *BaseGoogleSQLParserListener) ExitNot_null_column_attribute(ctx *Not_null_column_attributeContext) { +} + +// EnterPrimary_key_or_table_constraint_spec is called when production primary_key_or_table_constraint_spec is entered. +func (s *BaseGoogleSQLParserListener) EnterPrimary_key_or_table_constraint_spec(ctx *Primary_key_or_table_constraint_specContext) { +} + +// ExitPrimary_key_or_table_constraint_spec is called when production primary_key_or_table_constraint_spec is exited. +func (s *BaseGoogleSQLParserListener) ExitPrimary_key_or_table_constraint_spec(ctx *Primary_key_or_table_constraint_specContext) { +} + +// EnterOpt_if_not_exists is called when production opt_if_not_exists is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_if_not_exists(ctx *Opt_if_not_existsContext) {} + +// ExitOpt_if_not_exists is called when production opt_if_not_exists is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_if_not_exists(ctx *Opt_if_not_existsContext) {} + +// EnterPrimary_key_spec is called when production primary_key_spec is entered. +func (s *BaseGoogleSQLParserListener) EnterPrimary_key_spec(ctx *Primary_key_specContext) {} + +// ExitPrimary_key_spec is called when production primary_key_spec is exited. +func (s *BaseGoogleSQLParserListener) ExitPrimary_key_spec(ctx *Primary_key_specContext) {} + +// EnterPrimary_key_element_list is called when production primary_key_element_list is entered. +func (s *BaseGoogleSQLParserListener) EnterPrimary_key_element_list(ctx *Primary_key_element_listContext) { +} + +// ExitPrimary_key_element_list is called when production primary_key_element_list is exited. +func (s *BaseGoogleSQLParserListener) ExitPrimary_key_element_list(ctx *Primary_key_element_listContext) { +} + +// EnterPrimary_key_element is called when production primary_key_element is entered. +func (s *BaseGoogleSQLParserListener) EnterPrimary_key_element(ctx *Primary_key_elementContext) {} + +// ExitPrimary_key_element is called when production primary_key_element is exited. +func (s *BaseGoogleSQLParserListener) ExitPrimary_key_element(ctx *Primary_key_elementContext) {} + +// EnterTable_constraint_spec is called when production table_constraint_spec is entered. +func (s *BaseGoogleSQLParserListener) EnterTable_constraint_spec(ctx *Table_constraint_specContext) {} + +// ExitTable_constraint_spec is called when production table_constraint_spec is exited. +func (s *BaseGoogleSQLParserListener) ExitTable_constraint_spec(ctx *Table_constraint_specContext) {} + +// EnterForeign_key_reference is called when production foreign_key_reference is entered. +func (s *BaseGoogleSQLParserListener) EnterForeign_key_reference(ctx *Foreign_key_referenceContext) {} + +// ExitForeign_key_reference is called when production foreign_key_reference is exited. +func (s *BaseGoogleSQLParserListener) ExitForeign_key_reference(ctx *Foreign_key_referenceContext) {} + +// EnterOpt_foreign_key_action is called when production opt_foreign_key_action is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_foreign_key_action(ctx *Opt_foreign_key_actionContext) { +} + +// ExitOpt_foreign_key_action is called when production opt_foreign_key_action is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_foreign_key_action(ctx *Opt_foreign_key_actionContext) { +} + +// EnterForeign_key_on_update is called when production foreign_key_on_update is entered. +func (s *BaseGoogleSQLParserListener) EnterForeign_key_on_update(ctx *Foreign_key_on_updateContext) {} + +// ExitForeign_key_on_update is called when production foreign_key_on_update is exited. +func (s *BaseGoogleSQLParserListener) ExitForeign_key_on_update(ctx *Foreign_key_on_updateContext) {} + +// EnterForeign_key_on_delete is called when production foreign_key_on_delete is entered. +func (s *BaseGoogleSQLParserListener) EnterForeign_key_on_delete(ctx *Foreign_key_on_deleteContext) {} + +// ExitForeign_key_on_delete is called when production foreign_key_on_delete is exited. +func (s *BaseGoogleSQLParserListener) ExitForeign_key_on_delete(ctx *Foreign_key_on_deleteContext) {} + +// EnterForeign_key_action is called when production foreign_key_action is entered. +func (s *BaseGoogleSQLParserListener) EnterForeign_key_action(ctx *Foreign_key_actionContext) {} + +// ExitForeign_key_action is called when production foreign_key_action is exited. +func (s *BaseGoogleSQLParserListener) ExitForeign_key_action(ctx *Foreign_key_actionContext) {} + +// EnterOpt_foreign_key_match is called when production opt_foreign_key_match is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_foreign_key_match(ctx *Opt_foreign_key_matchContext) {} + +// ExitOpt_foreign_key_match is called when production opt_foreign_key_match is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_foreign_key_match(ctx *Opt_foreign_key_matchContext) {} + +// EnterForeign_key_match_mode is called when production foreign_key_match_mode is entered. +func (s *BaseGoogleSQLParserListener) EnterForeign_key_match_mode(ctx *Foreign_key_match_modeContext) { +} + +// ExitForeign_key_match_mode is called when production foreign_key_match_mode is exited. +func (s *BaseGoogleSQLParserListener) ExitForeign_key_match_mode(ctx *Foreign_key_match_modeContext) { +} + +// EnterColumn_list is called when production column_list is entered. +func (s *BaseGoogleSQLParserListener) EnterColumn_list(ctx *Column_listContext) {} + +// ExitColumn_list is called when production column_list is exited. +func (s *BaseGoogleSQLParserListener) ExitColumn_list(ctx *Column_listContext) {} + +// EnterOpt_options_list is called when production opt_options_list is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_options_list(ctx *Opt_options_listContext) {} + +// ExitOpt_options_list is called when production opt_options_list is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_options_list(ctx *Opt_options_listContext) {} + +// EnterConstraint_enforcement is called when production constraint_enforcement is entered. +func (s *BaseGoogleSQLParserListener) EnterConstraint_enforcement(ctx *Constraint_enforcementContext) { +} + +// ExitConstraint_enforcement is called when production constraint_enforcement is exited. +func (s *BaseGoogleSQLParserListener) ExitConstraint_enforcement(ctx *Constraint_enforcementContext) { +} + +// EnterGeneric_entity_body is called when production generic_entity_body is entered. +func (s *BaseGoogleSQLParserListener) EnterGeneric_entity_body(ctx *Generic_entity_bodyContext) {} + +// ExitGeneric_entity_body is called when production generic_entity_body is exited. +func (s *BaseGoogleSQLParserListener) ExitGeneric_entity_body(ctx *Generic_entity_bodyContext) {} + +// EnterOpt_if_exists is called when production opt_if_exists is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_if_exists(ctx *Opt_if_existsContext) {} + +// ExitOpt_if_exists is called when production opt_if_exists is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_if_exists(ctx *Opt_if_existsContext) {} + +// EnterTable_or_table_function is called when production table_or_table_function is entered. +func (s *BaseGoogleSQLParserListener) EnterTable_or_table_function(ctx *Table_or_table_functionContext) { +} + +// ExitTable_or_table_function is called when production table_or_table_function is exited. +func (s *BaseGoogleSQLParserListener) ExitTable_or_table_function(ctx *Table_or_table_functionContext) { +} + +// EnterQuery is called when production query is entered. +func (s *BaseGoogleSQLParserListener) EnterQuery(ctx *QueryContext) {} + +// ExitQuery is called when production query is exited. +func (s *BaseGoogleSQLParserListener) ExitQuery(ctx *QueryContext) {} + +// EnterQuery_without_pipe_operators is called when production query_without_pipe_operators is entered. +func (s *BaseGoogleSQLParserListener) EnterQuery_without_pipe_operators(ctx *Query_without_pipe_operatorsContext) { +} + +// ExitQuery_without_pipe_operators is called when production query_without_pipe_operators is exited. +func (s *BaseGoogleSQLParserListener) ExitQuery_without_pipe_operators(ctx *Query_without_pipe_operatorsContext) { +} + +// EnterBad_keyword_after_from_query is called when production bad_keyword_after_from_query is entered. +func (s *BaseGoogleSQLParserListener) EnterBad_keyword_after_from_query(ctx *Bad_keyword_after_from_queryContext) { +} + +// ExitBad_keyword_after_from_query is called when production bad_keyword_after_from_query is exited. +func (s *BaseGoogleSQLParserListener) ExitBad_keyword_after_from_query(ctx *Bad_keyword_after_from_queryContext) { +} + +// EnterBad_keyword_after_from_query_allows_parens is called when production bad_keyword_after_from_query_allows_parens is entered. +func (s *BaseGoogleSQLParserListener) EnterBad_keyword_after_from_query_allows_parens(ctx *Bad_keyword_after_from_query_allows_parensContext) { +} + +// ExitBad_keyword_after_from_query_allows_parens is called when production bad_keyword_after_from_query_allows_parens is exited. +func (s *BaseGoogleSQLParserListener) ExitBad_keyword_after_from_query_allows_parens(ctx *Bad_keyword_after_from_query_allows_parensContext) { +} + +// EnterWith_clause_with_trailing_comma is called when production with_clause_with_trailing_comma is entered. +func (s *BaseGoogleSQLParserListener) EnterWith_clause_with_trailing_comma(ctx *With_clause_with_trailing_commaContext) { +} + +// ExitWith_clause_with_trailing_comma is called when production with_clause_with_trailing_comma is exited. +func (s *BaseGoogleSQLParserListener) ExitWith_clause_with_trailing_comma(ctx *With_clause_with_trailing_commaContext) { +} + +// EnterSelect_or_from_keyword is called when production select_or_from_keyword is entered. +func (s *BaseGoogleSQLParserListener) EnterSelect_or_from_keyword(ctx *Select_or_from_keywordContext) { +} + +// ExitSelect_or_from_keyword is called when production select_or_from_keyword is exited. +func (s *BaseGoogleSQLParserListener) ExitSelect_or_from_keyword(ctx *Select_or_from_keywordContext) { +} + +// EnterQuery_primary_or_set_operation is called when production query_primary_or_set_operation is entered. +func (s *BaseGoogleSQLParserListener) EnterQuery_primary_or_set_operation(ctx *Query_primary_or_set_operationContext) { +} + +// ExitQuery_primary_or_set_operation is called when production query_primary_or_set_operation is exited. +func (s *BaseGoogleSQLParserListener) ExitQuery_primary_or_set_operation(ctx *Query_primary_or_set_operationContext) { +} + +// EnterQuery_set_operation is called when production query_set_operation is entered. +func (s *BaseGoogleSQLParserListener) EnterQuery_set_operation(ctx *Query_set_operationContext) {} + +// ExitQuery_set_operation is called when production query_set_operation is exited. +func (s *BaseGoogleSQLParserListener) ExitQuery_set_operation(ctx *Query_set_operationContext) {} + +// EnterQuery_set_operation_prefix is called when production query_set_operation_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterQuery_set_operation_prefix(ctx *Query_set_operation_prefixContext) { +} + +// ExitQuery_set_operation_prefix is called when production query_set_operation_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitQuery_set_operation_prefix(ctx *Query_set_operation_prefixContext) { +} + +// EnterQuery_set_operation_item is called when production query_set_operation_item is entered. +func (s *BaseGoogleSQLParserListener) EnterQuery_set_operation_item(ctx *Query_set_operation_itemContext) { +} + +// ExitQuery_set_operation_item is called when production query_set_operation_item is exited. +func (s *BaseGoogleSQLParserListener) ExitQuery_set_operation_item(ctx *Query_set_operation_itemContext) { +} + +// EnterQuery_primary is called when production query_primary is entered. +func (s *BaseGoogleSQLParserListener) EnterQuery_primary(ctx *Query_primaryContext) {} + +// ExitQuery_primary is called when production query_primary is exited. +func (s *BaseGoogleSQLParserListener) ExitQuery_primary(ctx *Query_primaryContext) {} + +// EnterSet_operation_metadata is called when production set_operation_metadata is entered. +func (s *BaseGoogleSQLParserListener) EnterSet_operation_metadata(ctx *Set_operation_metadataContext) { +} + +// ExitSet_operation_metadata is called when production set_operation_metadata is exited. +func (s *BaseGoogleSQLParserListener) ExitSet_operation_metadata(ctx *Set_operation_metadataContext) { +} + +// EnterOpt_column_match_suffix is called when production opt_column_match_suffix is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_column_match_suffix(ctx *Opt_column_match_suffixContext) { +} + +// ExitOpt_column_match_suffix is called when production opt_column_match_suffix is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_column_match_suffix(ctx *Opt_column_match_suffixContext) { +} + +// EnterOpt_strict is called when production opt_strict is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_strict(ctx *Opt_strictContext) {} + +// ExitOpt_strict is called when production opt_strict is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_strict(ctx *Opt_strictContext) {} + +// EnterAll_or_distinct is called when production all_or_distinct is entered. +func (s *BaseGoogleSQLParserListener) EnterAll_or_distinct(ctx *All_or_distinctContext) {} + +// ExitAll_or_distinct is called when production all_or_distinct is exited. +func (s *BaseGoogleSQLParserListener) ExitAll_or_distinct(ctx *All_or_distinctContext) {} + +// EnterQuery_set_operation_type is called when production query_set_operation_type is entered. +func (s *BaseGoogleSQLParserListener) EnterQuery_set_operation_type(ctx *Query_set_operation_typeContext) { +} + +// ExitQuery_set_operation_type is called when production query_set_operation_type is exited. +func (s *BaseGoogleSQLParserListener) ExitQuery_set_operation_type(ctx *Query_set_operation_typeContext) { +} + +// EnterOpt_corresponding_outer_mode is called when production opt_corresponding_outer_mode is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_corresponding_outer_mode(ctx *Opt_corresponding_outer_modeContext) { +} + +// ExitOpt_corresponding_outer_mode is called when production opt_corresponding_outer_mode is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_corresponding_outer_mode(ctx *Opt_corresponding_outer_modeContext) { +} + +// EnterOpt_outer is called when production opt_outer is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_outer(ctx *Opt_outerContext) {} + +// ExitOpt_outer is called when production opt_outer is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_outer(ctx *Opt_outerContext) {} + +// EnterWith_clause is called when production with_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterWith_clause(ctx *With_clauseContext) {} + +// ExitWith_clause is called when production with_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitWith_clause(ctx *With_clauseContext) {} + +// EnterAliased_query is called when production aliased_query is entered. +func (s *BaseGoogleSQLParserListener) EnterAliased_query(ctx *Aliased_queryContext) {} + +// ExitAliased_query is called when production aliased_query is exited. +func (s *BaseGoogleSQLParserListener) ExitAliased_query(ctx *Aliased_queryContext) {} + +// EnterOpt_aliased_query_modifiers is called when production opt_aliased_query_modifiers is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_aliased_query_modifiers(ctx *Opt_aliased_query_modifiersContext) { +} + +// ExitOpt_aliased_query_modifiers is called when production opt_aliased_query_modifiers is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_aliased_query_modifiers(ctx *Opt_aliased_query_modifiersContext) { +} + +// EnterRecursion_depth_modifier is called when production recursion_depth_modifier is entered. +func (s *BaseGoogleSQLParserListener) EnterRecursion_depth_modifier(ctx *Recursion_depth_modifierContext) { +} + +// ExitRecursion_depth_modifier is called when production recursion_depth_modifier is exited. +func (s *BaseGoogleSQLParserListener) ExitRecursion_depth_modifier(ctx *Recursion_depth_modifierContext) { +} + +// EnterPossibly_unbounded_int_literal_or_parameter is called when production possibly_unbounded_int_literal_or_parameter is entered. +func (s *BaseGoogleSQLParserListener) EnterPossibly_unbounded_int_literal_or_parameter(ctx *Possibly_unbounded_int_literal_or_parameterContext) { +} + +// ExitPossibly_unbounded_int_literal_or_parameter is called when production possibly_unbounded_int_literal_or_parameter is exited. +func (s *BaseGoogleSQLParserListener) ExitPossibly_unbounded_int_literal_or_parameter(ctx *Possibly_unbounded_int_literal_or_parameterContext) { +} + +// EnterInt_literal_or_parameter is called when production int_literal_or_parameter is entered. +func (s *BaseGoogleSQLParserListener) EnterInt_literal_or_parameter(ctx *Int_literal_or_parameterContext) { +} + +// ExitInt_literal_or_parameter is called when production int_literal_or_parameter is exited. +func (s *BaseGoogleSQLParserListener) ExitInt_literal_or_parameter(ctx *Int_literal_or_parameterContext) { +} + +// EnterOrder_by_clause is called when production order_by_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterOrder_by_clause(ctx *Order_by_clauseContext) {} + +// ExitOrder_by_clause is called when production order_by_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitOrder_by_clause(ctx *Order_by_clauseContext) {} + +// EnterOrder_by_clause_prefix is called when production order_by_clause_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterOrder_by_clause_prefix(ctx *Order_by_clause_prefixContext) { +} + +// ExitOrder_by_clause_prefix is called when production order_by_clause_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitOrder_by_clause_prefix(ctx *Order_by_clause_prefixContext) { +} + +// EnterOrdering_expression is called when production ordering_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterOrdering_expression(ctx *Ordering_expressionContext) {} + +// ExitOrdering_expression is called when production ordering_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitOrdering_expression(ctx *Ordering_expressionContext) {} + +// EnterSelect is called when production select is entered. +func (s *BaseGoogleSQLParserListener) EnterSelect(ctx *SelectContext) {} + +// ExitSelect is called when production select is exited. +func (s *BaseGoogleSQLParserListener) ExitSelect(ctx *SelectContext) {} + +// EnterOpt_clauses_following_from is called when production opt_clauses_following_from is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_clauses_following_from(ctx *Opt_clauses_following_fromContext) { +} + +// ExitOpt_clauses_following_from is called when production opt_clauses_following_from is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_clauses_following_from(ctx *Opt_clauses_following_fromContext) { +} + +// EnterOpt_clauses_following_where is called when production opt_clauses_following_where is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_clauses_following_where(ctx *Opt_clauses_following_whereContext) { +} + +// ExitOpt_clauses_following_where is called when production opt_clauses_following_where is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_clauses_following_where(ctx *Opt_clauses_following_whereContext) { +} + +// EnterOpt_clauses_following_group_by is called when production opt_clauses_following_group_by is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_clauses_following_group_by(ctx *Opt_clauses_following_group_byContext) { +} + +// ExitOpt_clauses_following_group_by is called when production opt_clauses_following_group_by is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_clauses_following_group_by(ctx *Opt_clauses_following_group_byContext) { +} + +// EnterWindow_clause is called when production window_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterWindow_clause(ctx *Window_clauseContext) {} + +// ExitWindow_clause is called when production window_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitWindow_clause(ctx *Window_clauseContext) {} + +// EnterWindow_clause_prefix is called when production window_clause_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterWindow_clause_prefix(ctx *Window_clause_prefixContext) {} + +// ExitWindow_clause_prefix is called when production window_clause_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitWindow_clause_prefix(ctx *Window_clause_prefixContext) {} + +// EnterWindow_definition is called when production window_definition is entered. +func (s *BaseGoogleSQLParserListener) EnterWindow_definition(ctx *Window_definitionContext) {} + +// ExitWindow_definition is called when production window_definition is exited. +func (s *BaseGoogleSQLParserListener) ExitWindow_definition(ctx *Window_definitionContext) {} + +// EnterWhere_clause is called when production where_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterWhere_clause(ctx *Where_clauseContext) {} + +// ExitWhere_clause is called when production where_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitWhere_clause(ctx *Where_clauseContext) {} + +// EnterHaving_clause is called when production having_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterHaving_clause(ctx *Having_clauseContext) {} + +// ExitHaving_clause is called when production having_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitHaving_clause(ctx *Having_clauseContext) {} + +// EnterGroup_by_clause is called when production group_by_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterGroup_by_clause(ctx *Group_by_clauseContext) {} + +// ExitGroup_by_clause is called when production group_by_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitGroup_by_clause(ctx *Group_by_clauseContext) {} + +// EnterGroup_by_all is called when production group_by_all is entered. +func (s *BaseGoogleSQLParserListener) EnterGroup_by_all(ctx *Group_by_allContext) {} + +// ExitGroup_by_all is called when production group_by_all is exited. +func (s *BaseGoogleSQLParserListener) ExitGroup_by_all(ctx *Group_by_allContext) {} + +// EnterSelect_clause is called when production select_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterSelect_clause(ctx *Select_clauseContext) {} + +// ExitSelect_clause is called when production select_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitSelect_clause(ctx *Select_clauseContext) {} + +// EnterOpt_select_as_clause is called when production opt_select_as_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_select_as_clause(ctx *Opt_select_as_clauseContext) {} + +// ExitOpt_select_as_clause is called when production opt_select_as_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_select_as_clause(ctx *Opt_select_as_clauseContext) {} + +// EnterOpt_select_with is called when production opt_select_with is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_select_with(ctx *Opt_select_withContext) {} + +// ExitOpt_select_with is called when production opt_select_with is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_select_with(ctx *Opt_select_withContext) {} + +// EnterFrom_clause is called when production from_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterFrom_clause(ctx *From_clauseContext) {} + +// ExitFrom_clause is called when production from_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitFrom_clause(ctx *From_clauseContext) {} + +// EnterFrom_clause_contents is called when production from_clause_contents is entered. +func (s *BaseGoogleSQLParserListener) EnterFrom_clause_contents(ctx *From_clause_contentsContext) {} + +// ExitFrom_clause_contents is called when production from_clause_contents is exited. +func (s *BaseGoogleSQLParserListener) ExitFrom_clause_contents(ctx *From_clause_contentsContext) {} + +// EnterFrom_clause_contents_suffix is called when production from_clause_contents_suffix is entered. +func (s *BaseGoogleSQLParserListener) EnterFrom_clause_contents_suffix(ctx *From_clause_contents_suffixContext) { +} + +// ExitFrom_clause_contents_suffix is called when production from_clause_contents_suffix is exited. +func (s *BaseGoogleSQLParserListener) ExitFrom_clause_contents_suffix(ctx *From_clause_contents_suffixContext) { +} + +// EnterTable_primary is called when production table_primary is entered. +func (s *BaseGoogleSQLParserListener) EnterTable_primary(ctx *Table_primaryContext) {} + +// ExitTable_primary is called when production table_primary is exited. +func (s *BaseGoogleSQLParserListener) ExitTable_primary(ctx *Table_primaryContext) {} + +// EnterTvf_with_suffixes is called when production tvf_with_suffixes is entered. +func (s *BaseGoogleSQLParserListener) EnterTvf_with_suffixes(ctx *Tvf_with_suffixesContext) {} + +// ExitTvf_with_suffixes is called when production tvf_with_suffixes is exited. +func (s *BaseGoogleSQLParserListener) ExitTvf_with_suffixes(ctx *Tvf_with_suffixesContext) {} + +// EnterPivot_or_unpivot_clause_and_aliases is called when production pivot_or_unpivot_clause_and_aliases is entered. +func (s *BaseGoogleSQLParserListener) EnterPivot_or_unpivot_clause_and_aliases(ctx *Pivot_or_unpivot_clause_and_aliasesContext) { +} + +// ExitPivot_or_unpivot_clause_and_aliases is called when production pivot_or_unpivot_clause_and_aliases is exited. +func (s *BaseGoogleSQLParserListener) ExitPivot_or_unpivot_clause_and_aliases(ctx *Pivot_or_unpivot_clause_and_aliasesContext) { +} + +// EnterAs_alias is called when production as_alias is entered. +func (s *BaseGoogleSQLParserListener) EnterAs_alias(ctx *As_aliasContext) {} + +// ExitAs_alias is called when production as_alias is exited. +func (s *BaseGoogleSQLParserListener) ExitAs_alias(ctx *As_aliasContext) {} + +// EnterSample_clause is called when production sample_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterSample_clause(ctx *Sample_clauseContext) {} + +// ExitSample_clause is called when production sample_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitSample_clause(ctx *Sample_clauseContext) {} + +// EnterOpt_sample_clause_suffix is called when production opt_sample_clause_suffix is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_sample_clause_suffix(ctx *Opt_sample_clause_suffixContext) { +} + +// ExitOpt_sample_clause_suffix is called when production opt_sample_clause_suffix is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_sample_clause_suffix(ctx *Opt_sample_clause_suffixContext) { +} + +// EnterRepeatable_clause is called when production repeatable_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterRepeatable_clause(ctx *Repeatable_clauseContext) {} + +// ExitRepeatable_clause is called when production repeatable_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitRepeatable_clause(ctx *Repeatable_clauseContext) {} + +// EnterPossibly_cast_int_literal_or_parameter is called when production possibly_cast_int_literal_or_parameter is entered. +func (s *BaseGoogleSQLParserListener) EnterPossibly_cast_int_literal_or_parameter(ctx *Possibly_cast_int_literal_or_parameterContext) { +} + +// ExitPossibly_cast_int_literal_or_parameter is called when production possibly_cast_int_literal_or_parameter is exited. +func (s *BaseGoogleSQLParserListener) ExitPossibly_cast_int_literal_or_parameter(ctx *Possibly_cast_int_literal_or_parameterContext) { +} + +// EnterCast_int_literal_or_parameter is called when production cast_int_literal_or_parameter is entered. +func (s *BaseGoogleSQLParserListener) EnterCast_int_literal_or_parameter(ctx *Cast_int_literal_or_parameterContext) { +} + +// ExitCast_int_literal_or_parameter is called when production cast_int_literal_or_parameter is exited. +func (s *BaseGoogleSQLParserListener) ExitCast_int_literal_or_parameter(ctx *Cast_int_literal_or_parameterContext) { +} + +// EnterSample_size is called when production sample_size is entered. +func (s *BaseGoogleSQLParserListener) EnterSample_size(ctx *Sample_sizeContext) {} + +// ExitSample_size is called when production sample_size is exited. +func (s *BaseGoogleSQLParserListener) ExitSample_size(ctx *Sample_sizeContext) {} + +// EnterSample_size_value is called when production sample_size_value is entered. +func (s *BaseGoogleSQLParserListener) EnterSample_size_value(ctx *Sample_size_valueContext) {} + +// ExitSample_size_value is called when production sample_size_value is exited. +func (s *BaseGoogleSQLParserListener) ExitSample_size_value(ctx *Sample_size_valueContext) {} + +// EnterSample_size_unit is called when production sample_size_unit is entered. +func (s *BaseGoogleSQLParserListener) EnterSample_size_unit(ctx *Sample_size_unitContext) {} + +// ExitSample_size_unit is called when production sample_size_unit is exited. +func (s *BaseGoogleSQLParserListener) ExitSample_size_unit(ctx *Sample_size_unitContext) {} + +// EnterPartition_by_clause_prefix_no_hint is called when production partition_by_clause_prefix_no_hint is entered. +func (s *BaseGoogleSQLParserListener) EnterPartition_by_clause_prefix_no_hint(ctx *Partition_by_clause_prefix_no_hintContext) { +} + +// ExitPartition_by_clause_prefix_no_hint is called when production partition_by_clause_prefix_no_hint is exited. +func (s *BaseGoogleSQLParserListener) ExitPartition_by_clause_prefix_no_hint(ctx *Partition_by_clause_prefix_no_hintContext) { +} + +// EnterMatch_recognize_clause is called when production match_recognize_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterMatch_recognize_clause(ctx *Match_recognize_clauseContext) { +} + +// ExitMatch_recognize_clause is called when production match_recognize_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitMatch_recognize_clause(ctx *Match_recognize_clauseContext) { +} + +// EnterRow_pattern_expr is called when production row_pattern_expr is entered. +func (s *BaseGoogleSQLParserListener) EnterRow_pattern_expr(ctx *Row_pattern_exprContext) {} + +// ExitRow_pattern_expr is called when production row_pattern_expr is exited. +func (s *BaseGoogleSQLParserListener) ExitRow_pattern_expr(ctx *Row_pattern_exprContext) {} + +// EnterRow_pattern_concatenation is called when production row_pattern_concatenation is entered. +func (s *BaseGoogleSQLParserListener) EnterRow_pattern_concatenation(ctx *Row_pattern_concatenationContext) { +} + +// ExitRow_pattern_concatenation is called when production row_pattern_concatenation is exited. +func (s *BaseGoogleSQLParserListener) ExitRow_pattern_concatenation(ctx *Row_pattern_concatenationContext) { +} + +// EnterRow_pattern_factor is called when production row_pattern_factor is entered. +func (s *BaseGoogleSQLParserListener) EnterRow_pattern_factor(ctx *Row_pattern_factorContext) {} + +// ExitRow_pattern_factor is called when production row_pattern_factor is exited. +func (s *BaseGoogleSQLParserListener) ExitRow_pattern_factor(ctx *Row_pattern_factorContext) {} + +// EnterSelect_list_prefix_with_as_aliases is called when production select_list_prefix_with_as_aliases is entered. +func (s *BaseGoogleSQLParserListener) EnterSelect_list_prefix_with_as_aliases(ctx *Select_list_prefix_with_as_aliasesContext) { +} + +// ExitSelect_list_prefix_with_as_aliases is called when production select_list_prefix_with_as_aliases is exited. +func (s *BaseGoogleSQLParserListener) ExitSelect_list_prefix_with_as_aliases(ctx *Select_list_prefix_with_as_aliasesContext) { +} + +// EnterSelect_column_expr_with_as_alias is called when production select_column_expr_with_as_alias is entered. +func (s *BaseGoogleSQLParserListener) EnterSelect_column_expr_with_as_alias(ctx *Select_column_expr_with_as_aliasContext) { +} + +// ExitSelect_column_expr_with_as_alias is called when production select_column_expr_with_as_alias is exited. +func (s *BaseGoogleSQLParserListener) ExitSelect_column_expr_with_as_alias(ctx *Select_column_expr_with_as_aliasContext) { +} + +// EnterTable_subquery is called when production table_subquery is entered. +func (s *BaseGoogleSQLParserListener) EnterTable_subquery(ctx *Table_subqueryContext) {} + +// ExitTable_subquery is called when production table_subquery is exited. +func (s *BaseGoogleSQLParserListener) ExitTable_subquery(ctx *Table_subqueryContext) {} + +// EnterJoin is called when production join is entered. +func (s *BaseGoogleSQLParserListener) EnterJoin(ctx *JoinContext) {} + +// ExitJoin is called when production join is exited. +func (s *BaseGoogleSQLParserListener) ExitJoin(ctx *JoinContext) {} + +// EnterJoin_item is called when production join_item is entered. +func (s *BaseGoogleSQLParserListener) EnterJoin_item(ctx *Join_itemContext) {} + +// ExitJoin_item is called when production join_item is exited. +func (s *BaseGoogleSQLParserListener) ExitJoin_item(ctx *Join_itemContext) {} + +// EnterOn_or_using_clause_list is called when production on_or_using_clause_list is entered. +func (s *BaseGoogleSQLParserListener) EnterOn_or_using_clause_list(ctx *On_or_using_clause_listContext) { +} + +// ExitOn_or_using_clause_list is called when production on_or_using_clause_list is exited. +func (s *BaseGoogleSQLParserListener) ExitOn_or_using_clause_list(ctx *On_or_using_clause_listContext) { +} + +// EnterOn_or_using_clause is called when production on_or_using_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterOn_or_using_clause(ctx *On_or_using_clauseContext) {} + +// ExitOn_or_using_clause is called when production on_or_using_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitOn_or_using_clause(ctx *On_or_using_clauseContext) {} + +// EnterUsing_clause is called when production using_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterUsing_clause(ctx *Using_clauseContext) {} + +// ExitUsing_clause is called when production using_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitUsing_clause(ctx *Using_clauseContext) {} + +// EnterJoin_hint is called when production join_hint is entered. +func (s *BaseGoogleSQLParserListener) EnterJoin_hint(ctx *Join_hintContext) {} + +// ExitJoin_hint is called when production join_hint is exited. +func (s *BaseGoogleSQLParserListener) ExitJoin_hint(ctx *Join_hintContext) {} + +// EnterTable_path_expression is called when production table_path_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterTable_path_expression(ctx *Table_path_expressionContext) {} + +// ExitTable_path_expression is called when production table_path_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitTable_path_expression(ctx *Table_path_expressionContext) {} + +// EnterOpt_at_system_time is called when production opt_at_system_time is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_at_system_time(ctx *Opt_at_system_timeContext) {} + +// ExitOpt_at_system_time is called when production opt_at_system_time is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_at_system_time(ctx *Opt_at_system_timeContext) {} + +// EnterOpt_with_offset_and_alias is called when production opt_with_offset_and_alias is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_with_offset_and_alias(ctx *Opt_with_offset_and_aliasContext) { +} + +// ExitOpt_with_offset_and_alias is called when production opt_with_offset_and_alias is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_with_offset_and_alias(ctx *Opt_with_offset_and_aliasContext) { +} + +// EnterOpt_pivot_or_unpivot_clause_and_alias is called when production opt_pivot_or_unpivot_clause_and_alias is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_pivot_or_unpivot_clause_and_alias(ctx *Opt_pivot_or_unpivot_clause_and_aliasContext) { +} + +// ExitOpt_pivot_or_unpivot_clause_and_alias is called when production opt_pivot_or_unpivot_clause_and_alias is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_pivot_or_unpivot_clause_and_alias(ctx *Opt_pivot_or_unpivot_clause_and_aliasContext) { +} + +// EnterTable_path_expression_base is called when production table_path_expression_base is entered. +func (s *BaseGoogleSQLParserListener) EnterTable_path_expression_base(ctx *Table_path_expression_baseContext) { +} + +// ExitTable_path_expression_base is called when production table_path_expression_base is exited. +func (s *BaseGoogleSQLParserListener) ExitTable_path_expression_base(ctx *Table_path_expression_baseContext) { +} + +// EnterMaybe_slashed_or_dashed_path_expression is called when production maybe_slashed_or_dashed_path_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterMaybe_slashed_or_dashed_path_expression(ctx *Maybe_slashed_or_dashed_path_expressionContext) { +} + +// ExitMaybe_slashed_or_dashed_path_expression is called when production maybe_slashed_or_dashed_path_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitMaybe_slashed_or_dashed_path_expression(ctx *Maybe_slashed_or_dashed_path_expressionContext) { +} + +// EnterMaybe_dashed_path_expression is called when production maybe_dashed_path_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterMaybe_dashed_path_expression(ctx *Maybe_dashed_path_expressionContext) { +} + +// ExitMaybe_dashed_path_expression is called when production maybe_dashed_path_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitMaybe_dashed_path_expression(ctx *Maybe_dashed_path_expressionContext) { +} + +// EnterDashed_path_expression is called when production dashed_path_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterDashed_path_expression(ctx *Dashed_path_expressionContext) { +} + +// ExitDashed_path_expression is called when production dashed_path_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitDashed_path_expression(ctx *Dashed_path_expressionContext) { +} + +// EnterDashed_identifier is called when production dashed_identifier is entered. +func (s *BaseGoogleSQLParserListener) EnterDashed_identifier(ctx *Dashed_identifierContext) {} + +// ExitDashed_identifier is called when production dashed_identifier is exited. +func (s *BaseGoogleSQLParserListener) ExitDashed_identifier(ctx *Dashed_identifierContext) {} + +// EnterSlashed_identifier is called when production slashed_identifier is entered. +func (s *BaseGoogleSQLParserListener) EnterSlashed_identifier(ctx *Slashed_identifierContext) {} + +// ExitSlashed_identifier is called when production slashed_identifier is exited. +func (s *BaseGoogleSQLParserListener) ExitSlashed_identifier(ctx *Slashed_identifierContext) {} + +// EnterIdentifier_or_integer is called when production identifier_or_integer is entered. +func (s *BaseGoogleSQLParserListener) EnterIdentifier_or_integer(ctx *Identifier_or_integerContext) {} + +// ExitIdentifier_or_integer is called when production identifier_or_integer is exited. +func (s *BaseGoogleSQLParserListener) ExitIdentifier_or_integer(ctx *Identifier_or_integerContext) {} + +// EnterSlashed_identifier_separator is called when production slashed_identifier_separator is entered. +func (s *BaseGoogleSQLParserListener) EnterSlashed_identifier_separator(ctx *Slashed_identifier_separatorContext) { +} + +// ExitSlashed_identifier_separator is called when production slashed_identifier_separator is exited. +func (s *BaseGoogleSQLParserListener) ExitSlashed_identifier_separator(ctx *Slashed_identifier_separatorContext) { +} + +// EnterSlashed_path_expression is called when production slashed_path_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterSlashed_path_expression(ctx *Slashed_path_expressionContext) { +} + +// ExitSlashed_path_expression is called when production slashed_path_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitSlashed_path_expression(ctx *Slashed_path_expressionContext) { +} + +// EnterUnnest_expression is called when production unnest_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterUnnest_expression(ctx *Unnest_expressionContext) {} + +// ExitUnnest_expression is called when production unnest_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitUnnest_expression(ctx *Unnest_expressionContext) {} + +// EnterUnnest_expression_prefix is called when production unnest_expression_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterUnnest_expression_prefix(ctx *Unnest_expression_prefixContext) { +} + +// ExitUnnest_expression_prefix is called when production unnest_expression_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitUnnest_expression_prefix(ctx *Unnest_expression_prefixContext) { +} + +// EnterOpt_array_zip_mode is called when production opt_array_zip_mode is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_array_zip_mode(ctx *Opt_array_zip_modeContext) {} + +// ExitOpt_array_zip_mode is called when production opt_array_zip_mode is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_array_zip_mode(ctx *Opt_array_zip_modeContext) {} + +// EnterExpression_with_opt_alias is called when production expression_with_opt_alias is entered. +func (s *BaseGoogleSQLParserListener) EnterExpression_with_opt_alias(ctx *Expression_with_opt_aliasContext) { +} + +// ExitExpression_with_opt_alias is called when production expression_with_opt_alias is exited. +func (s *BaseGoogleSQLParserListener) ExitExpression_with_opt_alias(ctx *Expression_with_opt_aliasContext) { +} + +// EnterTvf_prefix is called when production tvf_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterTvf_prefix(ctx *Tvf_prefixContext) {} + +// ExitTvf_prefix is called when production tvf_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitTvf_prefix(ctx *Tvf_prefixContext) {} + +// EnterTvf_argument is called when production tvf_argument is entered. +func (s *BaseGoogleSQLParserListener) EnterTvf_argument(ctx *Tvf_argumentContext) {} + +// ExitTvf_argument is called when production tvf_argument is exited. +func (s *BaseGoogleSQLParserListener) ExitTvf_argument(ctx *Tvf_argumentContext) {} + +// EnterConnection_clause is called when production connection_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterConnection_clause(ctx *Connection_clauseContext) {} + +// ExitConnection_clause is called when production connection_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitConnection_clause(ctx *Connection_clauseContext) {} + +// EnterPath_expression_or_default is called when production path_expression_or_default is entered. +func (s *BaseGoogleSQLParserListener) EnterPath_expression_or_default(ctx *Path_expression_or_defaultContext) { +} + +// ExitPath_expression_or_default is called when production path_expression_or_default is exited. +func (s *BaseGoogleSQLParserListener) ExitPath_expression_or_default(ctx *Path_expression_or_defaultContext) { +} + +// EnterDescriptor_argument is called when production descriptor_argument is entered. +func (s *BaseGoogleSQLParserListener) EnterDescriptor_argument(ctx *Descriptor_argumentContext) {} + +// ExitDescriptor_argument is called when production descriptor_argument is exited. +func (s *BaseGoogleSQLParserListener) ExitDescriptor_argument(ctx *Descriptor_argumentContext) {} + +// EnterDescriptor_column_list is called when production descriptor_column_list is entered. +func (s *BaseGoogleSQLParserListener) EnterDescriptor_column_list(ctx *Descriptor_column_listContext) { +} + +// ExitDescriptor_column_list is called when production descriptor_column_list is exited. +func (s *BaseGoogleSQLParserListener) ExitDescriptor_column_list(ctx *Descriptor_column_listContext) { +} + +// EnterDescriptor_column is called when production descriptor_column is entered. +func (s *BaseGoogleSQLParserListener) EnterDescriptor_column(ctx *Descriptor_columnContext) {} + +// ExitDescriptor_column is called when production descriptor_column is exited. +func (s *BaseGoogleSQLParserListener) ExitDescriptor_column(ctx *Descriptor_columnContext) {} + +// EnterTable_clause is called when production table_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterTable_clause(ctx *Table_clauseContext) {} + +// ExitTable_clause is called when production table_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitTable_clause(ctx *Table_clauseContext) {} + +// EnterModel_clause is called when production model_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterModel_clause(ctx *Model_clauseContext) {} + +// ExitModel_clause is called when production model_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitModel_clause(ctx *Model_clauseContext) {} + +// EnterQualify_clause_nonreserved is called when production qualify_clause_nonreserved is entered. +func (s *BaseGoogleSQLParserListener) EnterQualify_clause_nonreserved(ctx *Qualify_clause_nonreservedContext) { +} + +// ExitQualify_clause_nonreserved is called when production qualify_clause_nonreserved is exited. +func (s *BaseGoogleSQLParserListener) ExitQualify_clause_nonreserved(ctx *Qualify_clause_nonreservedContext) { +} + +// EnterUnpivot_clause is called when production unpivot_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterUnpivot_clause(ctx *Unpivot_clauseContext) {} + +// ExitUnpivot_clause is called when production unpivot_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitUnpivot_clause(ctx *Unpivot_clauseContext) {} + +// EnterUnpivot_in_item_list is called when production unpivot_in_item_list is entered. +func (s *BaseGoogleSQLParserListener) EnterUnpivot_in_item_list(ctx *Unpivot_in_item_listContext) {} + +// ExitUnpivot_in_item_list is called when production unpivot_in_item_list is exited. +func (s *BaseGoogleSQLParserListener) ExitUnpivot_in_item_list(ctx *Unpivot_in_item_listContext) {} + +// EnterUnpivot_in_item_list_prefix is called when production unpivot_in_item_list_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterUnpivot_in_item_list_prefix(ctx *Unpivot_in_item_list_prefixContext) { +} + +// ExitUnpivot_in_item_list_prefix is called when production unpivot_in_item_list_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitUnpivot_in_item_list_prefix(ctx *Unpivot_in_item_list_prefixContext) { +} + +// EnterUnpivot_in_item is called when production unpivot_in_item is entered. +func (s *BaseGoogleSQLParserListener) EnterUnpivot_in_item(ctx *Unpivot_in_itemContext) {} + +// ExitUnpivot_in_item is called when production unpivot_in_item is exited. +func (s *BaseGoogleSQLParserListener) ExitUnpivot_in_item(ctx *Unpivot_in_itemContext) {} + +// EnterOpt_as_string_or_integer is called when production opt_as_string_or_integer is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_as_string_or_integer(ctx *Opt_as_string_or_integerContext) { +} + +// ExitOpt_as_string_or_integer is called when production opt_as_string_or_integer is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_as_string_or_integer(ctx *Opt_as_string_or_integerContext) { +} + +// EnterPath_expression_list_with_opt_parens is called when production path_expression_list_with_opt_parens is entered. +func (s *BaseGoogleSQLParserListener) EnterPath_expression_list_with_opt_parens(ctx *Path_expression_list_with_opt_parensContext) { +} + +// ExitPath_expression_list_with_opt_parens is called when production path_expression_list_with_opt_parens is exited. +func (s *BaseGoogleSQLParserListener) ExitPath_expression_list_with_opt_parens(ctx *Path_expression_list_with_opt_parensContext) { +} + +// EnterPath_expression_list is called when production path_expression_list is entered. +func (s *BaseGoogleSQLParserListener) EnterPath_expression_list(ctx *Path_expression_listContext) {} + +// ExitPath_expression_list is called when production path_expression_list is exited. +func (s *BaseGoogleSQLParserListener) ExitPath_expression_list(ctx *Path_expression_listContext) {} + +// EnterUnpivot_nulls_filter is called when production unpivot_nulls_filter is entered. +func (s *BaseGoogleSQLParserListener) EnterUnpivot_nulls_filter(ctx *Unpivot_nulls_filterContext) {} + +// ExitUnpivot_nulls_filter is called when production unpivot_nulls_filter is exited. +func (s *BaseGoogleSQLParserListener) ExitUnpivot_nulls_filter(ctx *Unpivot_nulls_filterContext) {} + +// EnterPivot_clause is called when production pivot_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterPivot_clause(ctx *Pivot_clauseContext) {} + +// ExitPivot_clause is called when production pivot_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitPivot_clause(ctx *Pivot_clauseContext) {} + +// EnterPivot_expression_list is called when production pivot_expression_list is entered. +func (s *BaseGoogleSQLParserListener) EnterPivot_expression_list(ctx *Pivot_expression_listContext) {} + +// ExitPivot_expression_list is called when production pivot_expression_list is exited. +func (s *BaseGoogleSQLParserListener) ExitPivot_expression_list(ctx *Pivot_expression_listContext) {} + +// EnterPivot_expression is called when production pivot_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterPivot_expression(ctx *Pivot_expressionContext) {} + +// ExitPivot_expression is called when production pivot_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitPivot_expression(ctx *Pivot_expressionContext) {} + +// EnterPivot_value_list is called when production pivot_value_list is entered. +func (s *BaseGoogleSQLParserListener) EnterPivot_value_list(ctx *Pivot_value_listContext) {} + +// ExitPivot_value_list is called when production pivot_value_list is exited. +func (s *BaseGoogleSQLParserListener) ExitPivot_value_list(ctx *Pivot_value_listContext) {} + +// EnterPivot_value is called when production pivot_value is entered. +func (s *BaseGoogleSQLParserListener) EnterPivot_value(ctx *Pivot_valueContext) {} + +// ExitPivot_value is called when production pivot_value is exited. +func (s *BaseGoogleSQLParserListener) ExitPivot_value(ctx *Pivot_valueContext) {} + +// EnterTvf_prefix_no_args is called when production tvf_prefix_no_args is entered. +func (s *BaseGoogleSQLParserListener) EnterTvf_prefix_no_args(ctx *Tvf_prefix_no_argsContext) {} + +// ExitTvf_prefix_no_args is called when production tvf_prefix_no_args is exited. +func (s *BaseGoogleSQLParserListener) ExitTvf_prefix_no_args(ctx *Tvf_prefix_no_argsContext) {} + +// EnterJoin_type is called when production join_type is entered. +func (s *BaseGoogleSQLParserListener) EnterJoin_type(ctx *Join_typeContext) {} + +// ExitJoin_type is called when production join_type is exited. +func (s *BaseGoogleSQLParserListener) ExitJoin_type(ctx *Join_typeContext) {} + +// EnterOpt_natural is called when production opt_natural is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_natural(ctx *Opt_naturalContext) {} + +// ExitOpt_natural is called when production opt_natural is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_natural(ctx *Opt_naturalContext) {} + +// EnterOn_clause is called when production on_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterOn_clause(ctx *On_clauseContext) {} + +// ExitOn_clause is called when production on_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitOn_clause(ctx *On_clauseContext) {} + +// EnterSelect_list is called when production select_list is entered. +func (s *BaseGoogleSQLParserListener) EnterSelect_list(ctx *Select_listContext) {} + +// ExitSelect_list is called when production select_list is exited. +func (s *BaseGoogleSQLParserListener) ExitSelect_list(ctx *Select_listContext) {} + +// EnterSelect_list_item is called when production select_list_item is entered. +func (s *BaseGoogleSQLParserListener) EnterSelect_list_item(ctx *Select_list_itemContext) {} + +// ExitSelect_list_item is called when production select_list_item is exited. +func (s *BaseGoogleSQLParserListener) ExitSelect_list_item(ctx *Select_list_itemContext) {} + +// EnterSelect_column_star is called when production select_column_star is entered. +func (s *BaseGoogleSQLParserListener) EnterSelect_column_star(ctx *Select_column_starContext) {} + +// ExitSelect_column_star is called when production select_column_star is exited. +func (s *BaseGoogleSQLParserListener) ExitSelect_column_star(ctx *Select_column_starContext) {} + +// EnterSelect_column_expr is called when production select_column_expr is entered. +func (s *BaseGoogleSQLParserListener) EnterSelect_column_expr(ctx *Select_column_exprContext) {} + +// ExitSelect_column_expr is called when production select_column_expr is exited. +func (s *BaseGoogleSQLParserListener) ExitSelect_column_expr(ctx *Select_column_exprContext) {} + +// EnterSelect_column_dot_star is called when production select_column_dot_star is entered. +func (s *BaseGoogleSQLParserListener) EnterSelect_column_dot_star(ctx *Select_column_dot_starContext) { +} + +// ExitSelect_column_dot_star is called when production select_column_dot_star is exited. +func (s *BaseGoogleSQLParserListener) ExitSelect_column_dot_star(ctx *Select_column_dot_starContext) { +} + +// EnterStar_modifiers is called when production star_modifiers is entered. +func (s *BaseGoogleSQLParserListener) EnterStar_modifiers(ctx *Star_modifiersContext) {} + +// ExitStar_modifiers is called when production star_modifiers is exited. +func (s *BaseGoogleSQLParserListener) ExitStar_modifiers(ctx *Star_modifiersContext) {} + +// EnterStar_except_list is called when production star_except_list is entered. +func (s *BaseGoogleSQLParserListener) EnterStar_except_list(ctx *Star_except_listContext) {} + +// ExitStar_except_list is called when production star_except_list is exited. +func (s *BaseGoogleSQLParserListener) ExitStar_except_list(ctx *Star_except_listContext) {} + +// EnterStar_replace_list is called when production star_replace_list is entered. +func (s *BaseGoogleSQLParserListener) EnterStar_replace_list(ctx *Star_replace_listContext) {} + +// ExitStar_replace_list is called when production star_replace_list is exited. +func (s *BaseGoogleSQLParserListener) ExitStar_replace_list(ctx *Star_replace_listContext) {} + +// EnterStar_replace_item is called when production star_replace_item is entered. +func (s *BaseGoogleSQLParserListener) EnterStar_replace_item(ctx *Star_replace_itemContext) {} + +// ExitStar_replace_item is called when production star_replace_item is exited. +func (s *BaseGoogleSQLParserListener) ExitStar_replace_item(ctx *Star_replace_itemContext) {} + +// EnterExpression is called when production expression is entered. +func (s *BaseGoogleSQLParserListener) EnterExpression(ctx *ExpressionContext) {} + +// ExitExpression is called when production expression is exited. +func (s *BaseGoogleSQLParserListener) ExitExpression(ctx *ExpressionContext) {} + +// EnterExpression_higher_prec_than_and is called when production expression_higher_prec_than_and is entered. +func (s *BaseGoogleSQLParserListener) EnterExpression_higher_prec_than_and(ctx *Expression_higher_prec_than_andContext) { +} + +// ExitExpression_higher_prec_than_and is called when production expression_higher_prec_than_and is exited. +func (s *BaseGoogleSQLParserListener) ExitExpression_higher_prec_than_and(ctx *Expression_higher_prec_than_andContext) { +} + +// EnterExpression_maybe_parenthesized_not_a_query is called when production expression_maybe_parenthesized_not_a_query is entered. +func (s *BaseGoogleSQLParserListener) EnterExpression_maybe_parenthesized_not_a_query(ctx *Expression_maybe_parenthesized_not_a_queryContext) { +} + +// ExitExpression_maybe_parenthesized_not_a_query is called when production expression_maybe_parenthesized_not_a_query is exited. +func (s *BaseGoogleSQLParserListener) ExitExpression_maybe_parenthesized_not_a_query(ctx *Expression_maybe_parenthesized_not_a_queryContext) { +} + +// EnterParenthesized_in_rhs is called when production parenthesized_in_rhs is entered. +func (s *BaseGoogleSQLParserListener) EnterParenthesized_in_rhs(ctx *Parenthesized_in_rhsContext) {} + +// ExitParenthesized_in_rhs is called when production parenthesized_in_rhs is exited. +func (s *BaseGoogleSQLParserListener) ExitParenthesized_in_rhs(ctx *Parenthesized_in_rhsContext) {} + +// EnterUnary_operator is called when production unary_operator is entered. +func (s *BaseGoogleSQLParserListener) EnterUnary_operator(ctx *Unary_operatorContext) {} + +// ExitUnary_operator is called when production unary_operator is exited. +func (s *BaseGoogleSQLParserListener) ExitUnary_operator(ctx *Unary_operatorContext) {} + +// EnterComparative_operator is called when production comparative_operator is entered. +func (s *BaseGoogleSQLParserListener) EnterComparative_operator(ctx *Comparative_operatorContext) {} + +// ExitComparative_operator is called when production comparative_operator is exited. +func (s *BaseGoogleSQLParserListener) ExitComparative_operator(ctx *Comparative_operatorContext) {} + +// EnterShift_operator is called when production shift_operator is entered. +func (s *BaseGoogleSQLParserListener) EnterShift_operator(ctx *Shift_operatorContext) {} + +// ExitShift_operator is called when production shift_operator is exited. +func (s *BaseGoogleSQLParserListener) ExitShift_operator(ctx *Shift_operatorContext) {} + +// EnterAdditive_operator is called when production additive_operator is entered. +func (s *BaseGoogleSQLParserListener) EnterAdditive_operator(ctx *Additive_operatorContext) {} + +// ExitAdditive_operator is called when production additive_operator is exited. +func (s *BaseGoogleSQLParserListener) ExitAdditive_operator(ctx *Additive_operatorContext) {} + +// EnterMultiplicative_operator is called when production multiplicative_operator is entered. +func (s *BaseGoogleSQLParserListener) EnterMultiplicative_operator(ctx *Multiplicative_operatorContext) { +} + +// ExitMultiplicative_operator is called when production multiplicative_operator is exited. +func (s *BaseGoogleSQLParserListener) ExitMultiplicative_operator(ctx *Multiplicative_operatorContext) { +} + +// EnterIs_operator is called when production is_operator is entered. +func (s *BaseGoogleSQLParserListener) EnterIs_operator(ctx *Is_operatorContext) {} + +// ExitIs_operator is called when production is_operator is exited. +func (s *BaseGoogleSQLParserListener) ExitIs_operator(ctx *Is_operatorContext) {} + +// EnterBetween_operator is called when production between_operator is entered. +func (s *BaseGoogleSQLParserListener) EnterBetween_operator(ctx *Between_operatorContext) {} + +// ExitBetween_operator is called when production between_operator is exited. +func (s *BaseGoogleSQLParserListener) ExitBetween_operator(ctx *Between_operatorContext) {} + +// EnterIn_operator is called when production in_operator is entered. +func (s *BaseGoogleSQLParserListener) EnterIn_operator(ctx *In_operatorContext) {} + +// ExitIn_operator is called when production in_operator is exited. +func (s *BaseGoogleSQLParserListener) ExitIn_operator(ctx *In_operatorContext) {} + +// EnterDistinct_operator is called when production distinct_operator is entered. +func (s *BaseGoogleSQLParserListener) EnterDistinct_operator(ctx *Distinct_operatorContext) {} + +// ExitDistinct_operator is called when production distinct_operator is exited. +func (s *BaseGoogleSQLParserListener) ExitDistinct_operator(ctx *Distinct_operatorContext) {} + +// EnterParenthesized_query is called when production parenthesized_query is entered. +func (s *BaseGoogleSQLParserListener) EnterParenthesized_query(ctx *Parenthesized_queryContext) {} + +// ExitParenthesized_query is called when production parenthesized_query is exited. +func (s *BaseGoogleSQLParserListener) ExitParenthesized_query(ctx *Parenthesized_queryContext) {} + +// EnterParenthesized_expression_not_a_query is called when production parenthesized_expression_not_a_query is entered. +func (s *BaseGoogleSQLParserListener) EnterParenthesized_expression_not_a_query(ctx *Parenthesized_expression_not_a_queryContext) { +} + +// ExitParenthesized_expression_not_a_query is called when production parenthesized_expression_not_a_query is exited. +func (s *BaseGoogleSQLParserListener) ExitParenthesized_expression_not_a_query(ctx *Parenthesized_expression_not_a_queryContext) { +} + +// EnterParenthesized_anysomeall_list_in_rhs is called when production parenthesized_anysomeall_list_in_rhs is entered. +func (s *BaseGoogleSQLParserListener) EnterParenthesized_anysomeall_list_in_rhs(ctx *Parenthesized_anysomeall_list_in_rhsContext) { +} + +// ExitParenthesized_anysomeall_list_in_rhs is called when production parenthesized_anysomeall_list_in_rhs is exited. +func (s *BaseGoogleSQLParserListener) ExitParenthesized_anysomeall_list_in_rhs(ctx *Parenthesized_anysomeall_list_in_rhsContext) { +} + +// EnterAnd_expression is called when production and_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterAnd_expression(ctx *And_expressionContext) {} + +// ExitAnd_expression is called when production and_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitAnd_expression(ctx *And_expressionContext) {} + +// EnterIn_list_two_or_more_prefix is called when production in_list_two_or_more_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterIn_list_two_or_more_prefix(ctx *In_list_two_or_more_prefixContext) { +} + +// ExitIn_list_two_or_more_prefix is called when production in_list_two_or_more_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitIn_list_two_or_more_prefix(ctx *In_list_two_or_more_prefixContext) { +} + +// EnterAny_some_all is called when production any_some_all is entered. +func (s *BaseGoogleSQLParserListener) EnterAny_some_all(ctx *Any_some_allContext) {} + +// ExitAny_some_all is called when production any_some_all is exited. +func (s *BaseGoogleSQLParserListener) ExitAny_some_all(ctx *Any_some_allContext) {} + +// EnterLike_operator is called when production like_operator is entered. +func (s *BaseGoogleSQLParserListener) EnterLike_operator(ctx *Like_operatorContext) {} + +// ExitLike_operator is called when production like_operator is exited. +func (s *BaseGoogleSQLParserListener) ExitLike_operator(ctx *Like_operatorContext) {} + +// EnterExpression_subquery_with_keyword is called when production expression_subquery_with_keyword is entered. +func (s *BaseGoogleSQLParserListener) EnterExpression_subquery_with_keyword(ctx *Expression_subquery_with_keywordContext) { +} + +// ExitExpression_subquery_with_keyword is called when production expression_subquery_with_keyword is exited. +func (s *BaseGoogleSQLParserListener) ExitExpression_subquery_with_keyword(ctx *Expression_subquery_with_keywordContext) { +} + +// EnterStruct_constructor is called when production struct_constructor is entered. +func (s *BaseGoogleSQLParserListener) EnterStruct_constructor(ctx *Struct_constructorContext) {} + +// ExitStruct_constructor is called when production struct_constructor is exited. +func (s *BaseGoogleSQLParserListener) ExitStruct_constructor(ctx *Struct_constructorContext) {} + +// EnterStruct_constructor_prefix_with_keyword is called when production struct_constructor_prefix_with_keyword is entered. +func (s *BaseGoogleSQLParserListener) EnterStruct_constructor_prefix_with_keyword(ctx *Struct_constructor_prefix_with_keywordContext) { +} + +// ExitStruct_constructor_prefix_with_keyword is called when production struct_constructor_prefix_with_keyword is exited. +func (s *BaseGoogleSQLParserListener) ExitStruct_constructor_prefix_with_keyword(ctx *Struct_constructor_prefix_with_keywordContext) { +} + +// EnterStruct_constructor_arg is called when production struct_constructor_arg is entered. +func (s *BaseGoogleSQLParserListener) EnterStruct_constructor_arg(ctx *Struct_constructor_argContext) { +} + +// ExitStruct_constructor_arg is called when production struct_constructor_arg is exited. +func (s *BaseGoogleSQLParserListener) ExitStruct_constructor_arg(ctx *Struct_constructor_argContext) { +} + +// EnterStruct_constructor_prefix_without_keyword is called when production struct_constructor_prefix_without_keyword is entered. +func (s *BaseGoogleSQLParserListener) EnterStruct_constructor_prefix_without_keyword(ctx *Struct_constructor_prefix_without_keywordContext) { +} + +// ExitStruct_constructor_prefix_without_keyword is called when production struct_constructor_prefix_without_keyword is exited. +func (s *BaseGoogleSQLParserListener) ExitStruct_constructor_prefix_without_keyword(ctx *Struct_constructor_prefix_without_keywordContext) { +} + +// EnterStruct_constructor_prefix_with_keyword_no_arg is called when production struct_constructor_prefix_with_keyword_no_arg is entered. +func (s *BaseGoogleSQLParserListener) EnterStruct_constructor_prefix_with_keyword_no_arg(ctx *Struct_constructor_prefix_with_keyword_no_argContext) { +} + +// ExitStruct_constructor_prefix_with_keyword_no_arg is called when production struct_constructor_prefix_with_keyword_no_arg is exited. +func (s *BaseGoogleSQLParserListener) ExitStruct_constructor_prefix_with_keyword_no_arg(ctx *Struct_constructor_prefix_with_keyword_no_argContext) { +} + +// EnterInterval_expression is called when production interval_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterInterval_expression(ctx *Interval_expressionContext) {} + +// ExitInterval_expression is called when production interval_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitInterval_expression(ctx *Interval_expressionContext) {} + +// EnterFunction_call_expression_with_clauses is called when production function_call_expression_with_clauses is entered. +func (s *BaseGoogleSQLParserListener) EnterFunction_call_expression_with_clauses(ctx *Function_call_expression_with_clausesContext) { +} + +// ExitFunction_call_expression_with_clauses is called when production function_call_expression_with_clauses is exited. +func (s *BaseGoogleSQLParserListener) ExitFunction_call_expression_with_clauses(ctx *Function_call_expression_with_clausesContext) { +} + +// EnterFunction_call_expression_with_clauses_suffix is called when production function_call_expression_with_clauses_suffix is entered. +func (s *BaseGoogleSQLParserListener) EnterFunction_call_expression_with_clauses_suffix(ctx *Function_call_expression_with_clauses_suffixContext) { +} + +// ExitFunction_call_expression_with_clauses_suffix is called when production function_call_expression_with_clauses_suffix is exited. +func (s *BaseGoogleSQLParserListener) ExitFunction_call_expression_with_clauses_suffix(ctx *Function_call_expression_with_clauses_suffixContext) { +} + +// EnterOver_clause is called when production over_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterOver_clause(ctx *Over_clauseContext) {} + +// ExitOver_clause is called when production over_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitOver_clause(ctx *Over_clauseContext) {} + +// EnterWindow_specification is called when production window_specification is entered. +func (s *BaseGoogleSQLParserListener) EnterWindow_specification(ctx *Window_specificationContext) {} + +// ExitWindow_specification is called when production window_specification is exited. +func (s *BaseGoogleSQLParserListener) ExitWindow_specification(ctx *Window_specificationContext) {} + +// EnterOpt_window_frame_clause is called when production opt_window_frame_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_window_frame_clause(ctx *Opt_window_frame_clauseContext) { +} + +// ExitOpt_window_frame_clause is called when production opt_window_frame_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_window_frame_clause(ctx *Opt_window_frame_clauseContext) { +} + +// EnterWindow_frame_bound is called when production window_frame_bound is entered. +func (s *BaseGoogleSQLParserListener) EnterWindow_frame_bound(ctx *Window_frame_boundContext) {} + +// ExitWindow_frame_bound is called when production window_frame_bound is exited. +func (s *BaseGoogleSQLParserListener) ExitWindow_frame_bound(ctx *Window_frame_boundContext) {} + +// EnterPreceding_or_following is called when production preceding_or_following is entered. +func (s *BaseGoogleSQLParserListener) EnterPreceding_or_following(ctx *Preceding_or_followingContext) { +} + +// ExitPreceding_or_following is called when production preceding_or_following is exited. +func (s *BaseGoogleSQLParserListener) ExitPreceding_or_following(ctx *Preceding_or_followingContext) { +} + +// EnterFrame_unit is called when production frame_unit is entered. +func (s *BaseGoogleSQLParserListener) EnterFrame_unit(ctx *Frame_unitContext) {} + +// ExitFrame_unit is called when production frame_unit is exited. +func (s *BaseGoogleSQLParserListener) ExitFrame_unit(ctx *Frame_unitContext) {} + +// EnterPartition_by_clause is called when production partition_by_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterPartition_by_clause(ctx *Partition_by_clauseContext) {} + +// ExitPartition_by_clause is called when production partition_by_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitPartition_by_clause(ctx *Partition_by_clauseContext) {} + +// EnterPartition_by_clause_prefix is called when production partition_by_clause_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterPartition_by_clause_prefix(ctx *Partition_by_clause_prefixContext) { +} + +// ExitPartition_by_clause_prefix is called when production partition_by_clause_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitPartition_by_clause_prefix(ctx *Partition_by_clause_prefixContext) { +} + +// EnterWith_group_rows is called when production with_group_rows is entered. +func (s *BaseGoogleSQLParserListener) EnterWith_group_rows(ctx *With_group_rowsContext) {} + +// ExitWith_group_rows is called when production with_group_rows is exited. +func (s *BaseGoogleSQLParserListener) ExitWith_group_rows(ctx *With_group_rowsContext) {} + +// EnterWith_report_modifier is called when production with_report_modifier is entered. +func (s *BaseGoogleSQLParserListener) EnterWith_report_modifier(ctx *With_report_modifierContext) {} + +// ExitWith_report_modifier is called when production with_report_modifier is exited. +func (s *BaseGoogleSQLParserListener) ExitWith_report_modifier(ctx *With_report_modifierContext) {} + +// EnterClamped_between_modifier is called when production clamped_between_modifier is entered. +func (s *BaseGoogleSQLParserListener) EnterClamped_between_modifier(ctx *Clamped_between_modifierContext) { +} + +// ExitClamped_between_modifier is called when production clamped_between_modifier is exited. +func (s *BaseGoogleSQLParserListener) ExitClamped_between_modifier(ctx *Clamped_between_modifierContext) { +} + +// EnterWith_report_format is called when production with_report_format is entered. +func (s *BaseGoogleSQLParserListener) EnterWith_report_format(ctx *With_report_formatContext) {} + +// ExitWith_report_format is called when production with_report_format is exited. +func (s *BaseGoogleSQLParserListener) ExitWith_report_format(ctx *With_report_formatContext) {} + +// EnterOptions_list is called when production options_list is entered. +func (s *BaseGoogleSQLParserListener) EnterOptions_list(ctx *Options_listContext) {} + +// ExitOptions_list is called when production options_list is exited. +func (s *BaseGoogleSQLParserListener) ExitOptions_list(ctx *Options_listContext) {} + +// EnterOptions_list_prefix is called when production options_list_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterOptions_list_prefix(ctx *Options_list_prefixContext) {} + +// ExitOptions_list_prefix is called when production options_list_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitOptions_list_prefix(ctx *Options_list_prefixContext) {} + +// EnterOptions_entry is called when production options_entry is entered. +func (s *BaseGoogleSQLParserListener) EnterOptions_entry(ctx *Options_entryContext) {} + +// ExitOptions_entry is called when production options_entry is exited. +func (s *BaseGoogleSQLParserListener) ExitOptions_entry(ctx *Options_entryContext) {} + +// EnterExpression_or_proto is called when production expression_or_proto is entered. +func (s *BaseGoogleSQLParserListener) EnterExpression_or_proto(ctx *Expression_or_protoContext) {} + +// ExitExpression_or_proto is called when production expression_or_proto is exited. +func (s *BaseGoogleSQLParserListener) ExitExpression_or_proto(ctx *Expression_or_protoContext) {} + +// EnterOptions_assignment_operator is called when production options_assignment_operator is entered. +func (s *BaseGoogleSQLParserListener) EnterOptions_assignment_operator(ctx *Options_assignment_operatorContext) { +} + +// ExitOptions_assignment_operator is called when production options_assignment_operator is exited. +func (s *BaseGoogleSQLParserListener) ExitOptions_assignment_operator(ctx *Options_assignment_operatorContext) { +} + +// EnterOpt_null_handling_modifier is called when production opt_null_handling_modifier is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_null_handling_modifier(ctx *Opt_null_handling_modifierContext) { +} + +// ExitOpt_null_handling_modifier is called when production opt_null_handling_modifier is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_null_handling_modifier(ctx *Opt_null_handling_modifierContext) { +} + +// EnterFunction_call_argument is called when production function_call_argument is entered. +func (s *BaseGoogleSQLParserListener) EnterFunction_call_argument(ctx *Function_call_argumentContext) { +} + +// ExitFunction_call_argument is called when production function_call_argument is exited. +func (s *BaseGoogleSQLParserListener) ExitFunction_call_argument(ctx *Function_call_argumentContext) { +} + +// EnterSequence_arg is called when production sequence_arg is entered. +func (s *BaseGoogleSQLParserListener) EnterSequence_arg(ctx *Sequence_argContext) {} + +// ExitSequence_arg is called when production sequence_arg is exited. +func (s *BaseGoogleSQLParserListener) ExitSequence_arg(ctx *Sequence_argContext) {} + +// EnterNamed_argument is called when production named_argument is entered. +func (s *BaseGoogleSQLParserListener) EnterNamed_argument(ctx *Named_argumentContext) {} + +// ExitNamed_argument is called when production named_argument is exited. +func (s *BaseGoogleSQLParserListener) ExitNamed_argument(ctx *Named_argumentContext) {} + +// EnterLambda_argument is called when production lambda_argument is entered. +func (s *BaseGoogleSQLParserListener) EnterLambda_argument(ctx *Lambda_argumentContext) {} + +// ExitLambda_argument is called when production lambda_argument is exited. +func (s *BaseGoogleSQLParserListener) ExitLambda_argument(ctx *Lambda_argumentContext) {} + +// EnterLambda_argument_list is called when production lambda_argument_list is entered. +func (s *BaseGoogleSQLParserListener) EnterLambda_argument_list(ctx *Lambda_argument_listContext) {} + +// ExitLambda_argument_list is called when production lambda_argument_list is exited. +func (s *BaseGoogleSQLParserListener) ExitLambda_argument_list(ctx *Lambda_argument_listContext) {} + +// EnterLimit_offset_clause is called when production limit_offset_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterLimit_offset_clause(ctx *Limit_offset_clauseContext) {} + +// ExitLimit_offset_clause is called when production limit_offset_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitLimit_offset_clause(ctx *Limit_offset_clauseContext) {} + +// EnterOpt_having_or_group_by_modifier is called when production opt_having_or_group_by_modifier is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_having_or_group_by_modifier(ctx *Opt_having_or_group_by_modifierContext) { +} + +// ExitOpt_having_or_group_by_modifier is called when production opt_having_or_group_by_modifier is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_having_or_group_by_modifier(ctx *Opt_having_or_group_by_modifierContext) { +} + +// EnterGroup_by_clause_prefix is called when production group_by_clause_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterGroup_by_clause_prefix(ctx *Group_by_clause_prefixContext) { +} + +// ExitGroup_by_clause_prefix is called when production group_by_clause_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitGroup_by_clause_prefix(ctx *Group_by_clause_prefixContext) { +} + +// EnterGroup_by_preamble is called when production group_by_preamble is entered. +func (s *BaseGoogleSQLParserListener) EnterGroup_by_preamble(ctx *Group_by_preambleContext) {} + +// ExitGroup_by_preamble is called when production group_by_preamble is exited. +func (s *BaseGoogleSQLParserListener) ExitGroup_by_preamble(ctx *Group_by_preambleContext) {} + +// EnterOpt_and_order is called when production opt_and_order is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_and_order(ctx *Opt_and_orderContext) {} + +// ExitOpt_and_order is called when production opt_and_order is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_and_order(ctx *Opt_and_orderContext) {} + +// EnterHint is called when production hint is entered. +func (s *BaseGoogleSQLParserListener) EnterHint(ctx *HintContext) {} + +// ExitHint is called when production hint is exited. +func (s *BaseGoogleSQLParserListener) ExitHint(ctx *HintContext) {} + +// EnterHint_with_body is called when production hint_with_body is entered. +func (s *BaseGoogleSQLParserListener) EnterHint_with_body(ctx *Hint_with_bodyContext) {} + +// ExitHint_with_body is called when production hint_with_body is exited. +func (s *BaseGoogleSQLParserListener) ExitHint_with_body(ctx *Hint_with_bodyContext) {} + +// EnterHint_with_body_prefix is called when production hint_with_body_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterHint_with_body_prefix(ctx *Hint_with_body_prefixContext) {} + +// ExitHint_with_body_prefix is called when production hint_with_body_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitHint_with_body_prefix(ctx *Hint_with_body_prefixContext) {} + +// EnterHint_entry is called when production hint_entry is entered. +func (s *BaseGoogleSQLParserListener) EnterHint_entry(ctx *Hint_entryContext) {} + +// ExitHint_entry is called when production hint_entry is exited. +func (s *BaseGoogleSQLParserListener) ExitHint_entry(ctx *Hint_entryContext) {} + +// EnterIdentifier_in_hints is called when production identifier_in_hints is entered. +func (s *BaseGoogleSQLParserListener) EnterIdentifier_in_hints(ctx *Identifier_in_hintsContext) {} + +// ExitIdentifier_in_hints is called when production identifier_in_hints is exited. +func (s *BaseGoogleSQLParserListener) ExitIdentifier_in_hints(ctx *Identifier_in_hintsContext) {} + +// EnterExtra_identifier_in_hints_name is called when production extra_identifier_in_hints_name is entered. +func (s *BaseGoogleSQLParserListener) EnterExtra_identifier_in_hints_name(ctx *Extra_identifier_in_hints_nameContext) { +} + +// ExitExtra_identifier_in_hints_name is called when production extra_identifier_in_hints_name is exited. +func (s *BaseGoogleSQLParserListener) ExitExtra_identifier_in_hints_name(ctx *Extra_identifier_in_hints_nameContext) { +} + +// EnterGrouping_item is called when production grouping_item is entered. +func (s *BaseGoogleSQLParserListener) EnterGrouping_item(ctx *Grouping_itemContext) {} + +// ExitGrouping_item is called when production grouping_item is exited. +func (s *BaseGoogleSQLParserListener) ExitGrouping_item(ctx *Grouping_itemContext) {} + +// EnterGrouping_set_list is called when production grouping_set_list is entered. +func (s *BaseGoogleSQLParserListener) EnterGrouping_set_list(ctx *Grouping_set_listContext) {} + +// ExitGrouping_set_list is called when production grouping_set_list is exited. +func (s *BaseGoogleSQLParserListener) ExitGrouping_set_list(ctx *Grouping_set_listContext) {} + +// EnterGrouping_set is called when production grouping_set is entered. +func (s *BaseGoogleSQLParserListener) EnterGrouping_set(ctx *Grouping_setContext) {} + +// ExitGrouping_set is called when production grouping_set is exited. +func (s *BaseGoogleSQLParserListener) ExitGrouping_set(ctx *Grouping_setContext) {} + +// EnterCube_list is called when production cube_list is entered. +func (s *BaseGoogleSQLParserListener) EnterCube_list(ctx *Cube_listContext) {} + +// ExitCube_list is called when production cube_list is exited. +func (s *BaseGoogleSQLParserListener) ExitCube_list(ctx *Cube_listContext) {} + +// EnterRollup_list is called when production rollup_list is entered. +func (s *BaseGoogleSQLParserListener) EnterRollup_list(ctx *Rollup_listContext) {} + +// ExitRollup_list is called when production rollup_list is exited. +func (s *BaseGoogleSQLParserListener) ExitRollup_list(ctx *Rollup_listContext) {} + +// EnterOpt_as_alias_with_required_as is called when production opt_as_alias_with_required_as is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_as_alias_with_required_as(ctx *Opt_as_alias_with_required_asContext) { +} + +// ExitOpt_as_alias_with_required_as is called when production opt_as_alias_with_required_as is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_as_alias_with_required_as(ctx *Opt_as_alias_with_required_asContext) { +} + +// EnterOpt_grouping_item_order is called when production opt_grouping_item_order is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_grouping_item_order(ctx *Opt_grouping_item_orderContext) { +} + +// ExitOpt_grouping_item_order is called when production opt_grouping_item_order is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_grouping_item_order(ctx *Opt_grouping_item_orderContext) { +} + +// EnterOpt_selection_item_order is called when production opt_selection_item_order is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_selection_item_order(ctx *Opt_selection_item_orderContext) { +} + +// ExitOpt_selection_item_order is called when production opt_selection_item_order is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_selection_item_order(ctx *Opt_selection_item_orderContext) { +} + +// EnterAsc_or_desc is called when production asc_or_desc is entered. +func (s *BaseGoogleSQLParserListener) EnterAsc_or_desc(ctx *Asc_or_descContext) {} + +// ExitAsc_or_desc is called when production asc_or_desc is exited. +func (s *BaseGoogleSQLParserListener) ExitAsc_or_desc(ctx *Asc_or_descContext) {} + +// EnterNull_order is called when production null_order is entered. +func (s *BaseGoogleSQLParserListener) EnterNull_order(ctx *Null_orderContext) {} + +// ExitNull_order is called when production null_order is exited. +func (s *BaseGoogleSQLParserListener) ExitNull_order(ctx *Null_orderContext) {} + +// EnterFunction_name_from_keyword is called when production function_name_from_keyword is entered. +func (s *BaseGoogleSQLParserListener) EnterFunction_name_from_keyword(ctx *Function_name_from_keywordContext) { +} + +// ExitFunction_name_from_keyword is called when production function_name_from_keyword is exited. +func (s *BaseGoogleSQLParserListener) ExitFunction_name_from_keyword(ctx *Function_name_from_keywordContext) { +} + +// EnterReplace_fields_expression is called when production replace_fields_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterReplace_fields_expression(ctx *Replace_fields_expressionContext) { +} + +// ExitReplace_fields_expression is called when production replace_fields_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitReplace_fields_expression(ctx *Replace_fields_expressionContext) { +} + +// EnterReplace_fields_prefix is called when production replace_fields_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterReplace_fields_prefix(ctx *Replace_fields_prefixContext) {} + +// ExitReplace_fields_prefix is called when production replace_fields_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitReplace_fields_prefix(ctx *Replace_fields_prefixContext) {} + +// EnterReplace_fields_arg is called when production replace_fields_arg is entered. +func (s *BaseGoogleSQLParserListener) EnterReplace_fields_arg(ctx *Replace_fields_argContext) {} + +// ExitReplace_fields_arg is called when production replace_fields_arg is exited. +func (s *BaseGoogleSQLParserListener) ExitReplace_fields_arg(ctx *Replace_fields_argContext) {} + +// EnterGeneralized_path_expression is called when production generalized_path_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterGeneralized_path_expression(ctx *Generalized_path_expressionContext) { +} + +// ExitGeneralized_path_expression is called when production generalized_path_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitGeneralized_path_expression(ctx *Generalized_path_expressionContext) { +} + +// EnterGeneralized_extension_path is called when production generalized_extension_path is entered. +func (s *BaseGoogleSQLParserListener) EnterGeneralized_extension_path(ctx *Generalized_extension_pathContext) { +} + +// ExitGeneralized_extension_path is called when production generalized_extension_path is exited. +func (s *BaseGoogleSQLParserListener) ExitGeneralized_extension_path(ctx *Generalized_extension_pathContext) { +} + +// EnterWith_expression is called when production with_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterWith_expression(ctx *With_expressionContext) {} + +// ExitWith_expression is called when production with_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitWith_expression(ctx *With_expressionContext) {} + +// EnterWith_expression_variable_prefix is called when production with_expression_variable_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterWith_expression_variable_prefix(ctx *With_expression_variable_prefixContext) { +} + +// ExitWith_expression_variable_prefix is called when production with_expression_variable_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitWith_expression_variable_prefix(ctx *With_expression_variable_prefixContext) { +} + +// EnterWith_expression_variable is called when production with_expression_variable is entered. +func (s *BaseGoogleSQLParserListener) EnterWith_expression_variable(ctx *With_expression_variableContext) { +} + +// ExitWith_expression_variable is called when production with_expression_variable is exited. +func (s *BaseGoogleSQLParserListener) ExitWith_expression_variable(ctx *With_expression_variableContext) { +} + +// EnterExtract_expression is called when production extract_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterExtract_expression(ctx *Extract_expressionContext) {} + +// ExitExtract_expression is called when production extract_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitExtract_expression(ctx *Extract_expressionContext) {} + +// EnterExtract_expression_base is called when production extract_expression_base is entered. +func (s *BaseGoogleSQLParserListener) EnterExtract_expression_base(ctx *Extract_expression_baseContext) { +} + +// ExitExtract_expression_base is called when production extract_expression_base is exited. +func (s *BaseGoogleSQLParserListener) ExitExtract_expression_base(ctx *Extract_expression_baseContext) { +} + +// EnterOpt_format is called when production opt_format is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_format(ctx *Opt_formatContext) {} + +// ExitOpt_format is called when production opt_format is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_format(ctx *Opt_formatContext) {} + +// EnterOpt_at_time_zone is called when production opt_at_time_zone is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_at_time_zone(ctx *Opt_at_time_zoneContext) {} + +// ExitOpt_at_time_zone is called when production opt_at_time_zone is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_at_time_zone(ctx *Opt_at_time_zoneContext) {} + +// EnterCast_expression is called when production cast_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterCast_expression(ctx *Cast_expressionContext) {} + +// ExitCast_expression is called when production cast_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitCast_expression(ctx *Cast_expressionContext) {} + +// EnterCase_expression is called when production case_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterCase_expression(ctx *Case_expressionContext) {} + +// ExitCase_expression is called when production case_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitCase_expression(ctx *Case_expressionContext) {} + +// EnterCase_expression_prefix is called when production case_expression_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterCase_expression_prefix(ctx *Case_expression_prefixContext) { +} + +// ExitCase_expression_prefix is called when production case_expression_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitCase_expression_prefix(ctx *Case_expression_prefixContext) { +} + +// EnterCase_value_expression_prefix is called when production case_value_expression_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterCase_value_expression_prefix(ctx *Case_value_expression_prefixContext) { +} + +// ExitCase_value_expression_prefix is called when production case_value_expression_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitCase_value_expression_prefix(ctx *Case_value_expression_prefixContext) { +} + +// EnterCase_no_value_expression_prefix is called when production case_no_value_expression_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterCase_no_value_expression_prefix(ctx *Case_no_value_expression_prefixContext) { +} + +// ExitCase_no_value_expression_prefix is called when production case_no_value_expression_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitCase_no_value_expression_prefix(ctx *Case_no_value_expression_prefixContext) { +} + +// EnterStruct_braced_constructor is called when production struct_braced_constructor is entered. +func (s *BaseGoogleSQLParserListener) EnterStruct_braced_constructor(ctx *Struct_braced_constructorContext) { +} + +// ExitStruct_braced_constructor is called when production struct_braced_constructor is exited. +func (s *BaseGoogleSQLParserListener) ExitStruct_braced_constructor(ctx *Struct_braced_constructorContext) { +} + +// EnterBraced_new_constructor is called when production braced_new_constructor is entered. +func (s *BaseGoogleSQLParserListener) EnterBraced_new_constructor(ctx *Braced_new_constructorContext) { +} + +// ExitBraced_new_constructor is called when production braced_new_constructor is exited. +func (s *BaseGoogleSQLParserListener) ExitBraced_new_constructor(ctx *Braced_new_constructorContext) { +} + +// EnterBraced_constructor is called when production braced_constructor is entered. +func (s *BaseGoogleSQLParserListener) EnterBraced_constructor(ctx *Braced_constructorContext) {} + +// ExitBraced_constructor is called when production braced_constructor is exited. +func (s *BaseGoogleSQLParserListener) ExitBraced_constructor(ctx *Braced_constructorContext) {} + +// EnterBraced_constructor_start is called when production braced_constructor_start is entered. +func (s *BaseGoogleSQLParserListener) EnterBraced_constructor_start(ctx *Braced_constructor_startContext) { +} + +// ExitBraced_constructor_start is called when production braced_constructor_start is exited. +func (s *BaseGoogleSQLParserListener) ExitBraced_constructor_start(ctx *Braced_constructor_startContext) { +} + +// EnterBraced_constructor_prefix is called when production braced_constructor_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterBraced_constructor_prefix(ctx *Braced_constructor_prefixContext) { +} + +// ExitBraced_constructor_prefix is called when production braced_constructor_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitBraced_constructor_prefix(ctx *Braced_constructor_prefixContext) { +} + +// EnterBraced_constructor_field is called when production braced_constructor_field is entered. +func (s *BaseGoogleSQLParserListener) EnterBraced_constructor_field(ctx *Braced_constructor_fieldContext) { +} + +// ExitBraced_constructor_field is called when production braced_constructor_field is exited. +func (s *BaseGoogleSQLParserListener) ExitBraced_constructor_field(ctx *Braced_constructor_fieldContext) { +} + +// EnterBraced_constructor_lhs is called when production braced_constructor_lhs is entered. +func (s *BaseGoogleSQLParserListener) EnterBraced_constructor_lhs(ctx *Braced_constructor_lhsContext) { +} + +// ExitBraced_constructor_lhs is called when production braced_constructor_lhs is exited. +func (s *BaseGoogleSQLParserListener) ExitBraced_constructor_lhs(ctx *Braced_constructor_lhsContext) { +} + +// EnterBraced_constructor_field_value is called when production braced_constructor_field_value is entered. +func (s *BaseGoogleSQLParserListener) EnterBraced_constructor_field_value(ctx *Braced_constructor_field_valueContext) { +} + +// ExitBraced_constructor_field_value is called when production braced_constructor_field_value is exited. +func (s *BaseGoogleSQLParserListener) ExitBraced_constructor_field_value(ctx *Braced_constructor_field_valueContext) { +} + +// EnterBraced_constructor_extension is called when production braced_constructor_extension is entered. +func (s *BaseGoogleSQLParserListener) EnterBraced_constructor_extension(ctx *Braced_constructor_extensionContext) { +} + +// ExitBraced_constructor_extension is called when production braced_constructor_extension is exited. +func (s *BaseGoogleSQLParserListener) ExitBraced_constructor_extension(ctx *Braced_constructor_extensionContext) { +} + +// EnterNew_constructor is called when production new_constructor is entered. +func (s *BaseGoogleSQLParserListener) EnterNew_constructor(ctx *New_constructorContext) {} + +// ExitNew_constructor is called when production new_constructor is exited. +func (s *BaseGoogleSQLParserListener) ExitNew_constructor(ctx *New_constructorContext) {} + +// EnterNew_constructor_prefix is called when production new_constructor_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterNew_constructor_prefix(ctx *New_constructor_prefixContext) { +} + +// ExitNew_constructor_prefix is called when production new_constructor_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitNew_constructor_prefix(ctx *New_constructor_prefixContext) { +} + +// EnterNew_constructor_prefix_no_arg is called when production new_constructor_prefix_no_arg is entered. +func (s *BaseGoogleSQLParserListener) EnterNew_constructor_prefix_no_arg(ctx *New_constructor_prefix_no_argContext) { +} + +// ExitNew_constructor_prefix_no_arg is called when production new_constructor_prefix_no_arg is exited. +func (s *BaseGoogleSQLParserListener) ExitNew_constructor_prefix_no_arg(ctx *New_constructor_prefix_no_argContext) { +} + +// EnterNew_constructor_arg is called when production new_constructor_arg is entered. +func (s *BaseGoogleSQLParserListener) EnterNew_constructor_arg(ctx *New_constructor_argContext) {} + +// ExitNew_constructor_arg is called when production new_constructor_arg is exited. +func (s *BaseGoogleSQLParserListener) ExitNew_constructor_arg(ctx *New_constructor_argContext) {} + +// EnterArray_constructor is called when production array_constructor is entered. +func (s *BaseGoogleSQLParserListener) EnterArray_constructor(ctx *Array_constructorContext) {} + +// ExitArray_constructor is called when production array_constructor is exited. +func (s *BaseGoogleSQLParserListener) ExitArray_constructor(ctx *Array_constructorContext) {} + +// EnterArray_constructor_prefix is called when production array_constructor_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterArray_constructor_prefix(ctx *Array_constructor_prefixContext) { +} + +// ExitArray_constructor_prefix is called when production array_constructor_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitArray_constructor_prefix(ctx *Array_constructor_prefixContext) { +} + +// EnterArray_constructor_prefix_no_expressions is called when production array_constructor_prefix_no_expressions is entered. +func (s *BaseGoogleSQLParserListener) EnterArray_constructor_prefix_no_expressions(ctx *Array_constructor_prefix_no_expressionsContext) { +} + +// ExitArray_constructor_prefix_no_expressions is called when production array_constructor_prefix_no_expressions is exited. +func (s *BaseGoogleSQLParserListener) ExitArray_constructor_prefix_no_expressions(ctx *Array_constructor_prefix_no_expressionsContext) { +} + +// EnterRange_literal is called when production range_literal is entered. +func (s *BaseGoogleSQLParserListener) EnterRange_literal(ctx *Range_literalContext) {} + +// ExitRange_literal is called when production range_literal is exited. +func (s *BaseGoogleSQLParserListener) ExitRange_literal(ctx *Range_literalContext) {} + +// EnterRange_type is called when production range_type is entered. +func (s *BaseGoogleSQLParserListener) EnterRange_type(ctx *Range_typeContext) {} + +// ExitRange_type is called when production range_type is exited. +func (s *BaseGoogleSQLParserListener) ExitRange_type(ctx *Range_typeContext) {} + +// EnterType is called when production type is entered. +func (s *BaseGoogleSQLParserListener) EnterType(ctx *TypeContext) {} + +// ExitType is called when production type is exited. +func (s *BaseGoogleSQLParserListener) ExitType(ctx *TypeContext) {} + +// EnterCollate_clause is called when production collate_clause is entered. +func (s *BaseGoogleSQLParserListener) EnterCollate_clause(ctx *Collate_clauseContext) {} + +// ExitCollate_clause is called when production collate_clause is exited. +func (s *BaseGoogleSQLParserListener) ExitCollate_clause(ctx *Collate_clauseContext) {} + +// EnterString_literal_or_parameter is called when production string_literal_or_parameter is entered. +func (s *BaseGoogleSQLParserListener) EnterString_literal_or_parameter(ctx *String_literal_or_parameterContext) { +} + +// ExitString_literal_or_parameter is called when production string_literal_or_parameter is exited. +func (s *BaseGoogleSQLParserListener) ExitString_literal_or_parameter(ctx *String_literal_or_parameterContext) { +} + +// EnterSystem_variable_expression is called when production system_variable_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterSystem_variable_expression(ctx *System_variable_expressionContext) { +} + +// ExitSystem_variable_expression is called when production system_variable_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitSystem_variable_expression(ctx *System_variable_expressionContext) { +} + +// EnterParameter_expression is called when production parameter_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterParameter_expression(ctx *Parameter_expressionContext) {} + +// ExitParameter_expression is called when production parameter_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitParameter_expression(ctx *Parameter_expressionContext) {} + +// EnterNamed_parameter_expression is called when production named_parameter_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterNamed_parameter_expression(ctx *Named_parameter_expressionContext) { +} + +// ExitNamed_parameter_expression is called when production named_parameter_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitNamed_parameter_expression(ctx *Named_parameter_expressionContext) { +} + +// EnterOpt_type_parameters is called when production opt_type_parameters is entered. +func (s *BaseGoogleSQLParserListener) EnterOpt_type_parameters(ctx *Opt_type_parametersContext) {} + +// ExitOpt_type_parameters is called when production opt_type_parameters is exited. +func (s *BaseGoogleSQLParserListener) ExitOpt_type_parameters(ctx *Opt_type_parametersContext) {} + +// EnterType_parameters_prefix is called when production type_parameters_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterType_parameters_prefix(ctx *Type_parameters_prefixContext) { +} + +// ExitType_parameters_prefix is called when production type_parameters_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitType_parameters_prefix(ctx *Type_parameters_prefixContext) { +} + +// EnterType_parameter is called when production type_parameter is entered. +func (s *BaseGoogleSQLParserListener) EnterType_parameter(ctx *Type_parameterContext) {} + +// ExitType_parameter is called when production type_parameter is exited. +func (s *BaseGoogleSQLParserListener) ExitType_parameter(ctx *Type_parameterContext) {} + +// EnterRaw_type is called when production raw_type is entered. +func (s *BaseGoogleSQLParserListener) EnterRaw_type(ctx *Raw_typeContext) {} + +// ExitRaw_type is called when production raw_type is exited. +func (s *BaseGoogleSQLParserListener) ExitRaw_type(ctx *Raw_typeContext) {} + +// EnterMap_type is called when production map_type is entered. +func (s *BaseGoogleSQLParserListener) EnterMap_type(ctx *Map_typeContext) {} + +// ExitMap_type is called when production map_type is exited. +func (s *BaseGoogleSQLParserListener) ExitMap_type(ctx *Map_typeContext) {} + +// EnterFunction_type is called when production function_type is entered. +func (s *BaseGoogleSQLParserListener) EnterFunction_type(ctx *Function_typeContext) {} + +// ExitFunction_type is called when production function_type is exited. +func (s *BaseGoogleSQLParserListener) ExitFunction_type(ctx *Function_typeContext) {} + +// EnterFunction_type_prefix is called when production function_type_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterFunction_type_prefix(ctx *Function_type_prefixContext) {} + +// ExitFunction_type_prefix is called when production function_type_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitFunction_type_prefix(ctx *Function_type_prefixContext) {} + +// EnterType_name is called when production type_name is entered. +func (s *BaseGoogleSQLParserListener) EnterType_name(ctx *Type_nameContext) {} + +// ExitType_name is called when production type_name is exited. +func (s *BaseGoogleSQLParserListener) ExitType_name(ctx *Type_nameContext) {} + +// EnterPath_expression is called when production path_expression is entered. +func (s *BaseGoogleSQLParserListener) EnterPath_expression(ctx *Path_expressionContext) {} + +// ExitPath_expression is called when production path_expression is exited. +func (s *BaseGoogleSQLParserListener) ExitPath_expression(ctx *Path_expressionContext) {} + +// EnterIdentifier is called when production identifier is entered. +func (s *BaseGoogleSQLParserListener) EnterIdentifier(ctx *IdentifierContext) {} + +// ExitIdentifier is called when production identifier is exited. +func (s *BaseGoogleSQLParserListener) ExitIdentifier(ctx *IdentifierContext) {} + +// EnterKeyword_as_identifier is called when production keyword_as_identifier is entered. +func (s *BaseGoogleSQLParserListener) EnterKeyword_as_identifier(ctx *Keyword_as_identifierContext) {} + +// ExitKeyword_as_identifier is called when production keyword_as_identifier is exited. +func (s *BaseGoogleSQLParserListener) ExitKeyword_as_identifier(ctx *Keyword_as_identifierContext) {} + +// EnterCommon_keyword_as_identifier is called when production common_keyword_as_identifier is entered. +func (s *BaseGoogleSQLParserListener) EnterCommon_keyword_as_identifier(ctx *Common_keyword_as_identifierContext) { +} + +// ExitCommon_keyword_as_identifier is called when production common_keyword_as_identifier is exited. +func (s *BaseGoogleSQLParserListener) ExitCommon_keyword_as_identifier(ctx *Common_keyword_as_identifierContext) { +} + +// EnterToken_identifier is called when production token_identifier is entered. +func (s *BaseGoogleSQLParserListener) EnterToken_identifier(ctx *Token_identifierContext) {} + +// ExitToken_identifier is called when production token_identifier is exited. +func (s *BaseGoogleSQLParserListener) ExitToken_identifier(ctx *Token_identifierContext) {} + +// EnterStruct_type is called when production struct_type is entered. +func (s *BaseGoogleSQLParserListener) EnterStruct_type(ctx *Struct_typeContext) {} + +// ExitStruct_type is called when production struct_type is exited. +func (s *BaseGoogleSQLParserListener) ExitStruct_type(ctx *Struct_typeContext) {} + +// EnterStruct_type_prefix is called when production struct_type_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterStruct_type_prefix(ctx *Struct_type_prefixContext) {} + +// ExitStruct_type_prefix is called when production struct_type_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitStruct_type_prefix(ctx *Struct_type_prefixContext) {} + +// EnterStruct_field is called when production struct_field is entered. +func (s *BaseGoogleSQLParserListener) EnterStruct_field(ctx *Struct_fieldContext) {} + +// ExitStruct_field is called when production struct_field is exited. +func (s *BaseGoogleSQLParserListener) ExitStruct_field(ctx *Struct_fieldContext) {} + +// EnterArray_type is called when production array_type is entered. +func (s *BaseGoogleSQLParserListener) EnterArray_type(ctx *Array_typeContext) {} + +// ExitArray_type is called when production array_type is exited. +func (s *BaseGoogleSQLParserListener) ExitArray_type(ctx *Array_typeContext) {} + +// EnterTemplate_type_open is called when production template_type_open is entered. +func (s *BaseGoogleSQLParserListener) EnterTemplate_type_open(ctx *Template_type_openContext) {} + +// ExitTemplate_type_open is called when production template_type_open is exited. +func (s *BaseGoogleSQLParserListener) ExitTemplate_type_open(ctx *Template_type_openContext) {} + +// EnterTemplate_type_close is called when production template_type_close is entered. +func (s *BaseGoogleSQLParserListener) EnterTemplate_type_close(ctx *Template_type_closeContext) {} + +// ExitTemplate_type_close is called when production template_type_close is exited. +func (s *BaseGoogleSQLParserListener) ExitTemplate_type_close(ctx *Template_type_closeContext) {} + +// EnterDate_or_time_literal is called when production date_or_time_literal is entered. +func (s *BaseGoogleSQLParserListener) EnterDate_or_time_literal(ctx *Date_or_time_literalContext) {} + +// ExitDate_or_time_literal is called when production date_or_time_literal is exited. +func (s *BaseGoogleSQLParserListener) ExitDate_or_time_literal(ctx *Date_or_time_literalContext) {} + +// EnterDate_or_time_literal_kind is called when production date_or_time_literal_kind is entered. +func (s *BaseGoogleSQLParserListener) EnterDate_or_time_literal_kind(ctx *Date_or_time_literal_kindContext) { +} + +// ExitDate_or_time_literal_kind is called when production date_or_time_literal_kind is exited. +func (s *BaseGoogleSQLParserListener) ExitDate_or_time_literal_kind(ctx *Date_or_time_literal_kindContext) { +} + +// EnterFloating_point_literal is called when production floating_point_literal is entered. +func (s *BaseGoogleSQLParserListener) EnterFloating_point_literal(ctx *Floating_point_literalContext) { +} + +// ExitFloating_point_literal is called when production floating_point_literal is exited. +func (s *BaseGoogleSQLParserListener) ExitFloating_point_literal(ctx *Floating_point_literalContext) { +} + +// EnterJson_literal is called when production json_literal is entered. +func (s *BaseGoogleSQLParserListener) EnterJson_literal(ctx *Json_literalContext) {} + +// ExitJson_literal is called when production json_literal is exited. +func (s *BaseGoogleSQLParserListener) ExitJson_literal(ctx *Json_literalContext) {} + +// EnterBignumeric_literal is called when production bignumeric_literal is entered. +func (s *BaseGoogleSQLParserListener) EnterBignumeric_literal(ctx *Bignumeric_literalContext) {} + +// ExitBignumeric_literal is called when production bignumeric_literal is exited. +func (s *BaseGoogleSQLParserListener) ExitBignumeric_literal(ctx *Bignumeric_literalContext) {} + +// EnterBignumeric_literal_prefix is called when production bignumeric_literal_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterBignumeric_literal_prefix(ctx *Bignumeric_literal_prefixContext) { +} + +// ExitBignumeric_literal_prefix is called when production bignumeric_literal_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitBignumeric_literal_prefix(ctx *Bignumeric_literal_prefixContext) { +} + +// EnterNumeric_literal is called when production numeric_literal is entered. +func (s *BaseGoogleSQLParserListener) EnterNumeric_literal(ctx *Numeric_literalContext) {} + +// ExitNumeric_literal is called when production numeric_literal is exited. +func (s *BaseGoogleSQLParserListener) ExitNumeric_literal(ctx *Numeric_literalContext) {} + +// EnterNumeric_literal_prefix is called when production numeric_literal_prefix is entered. +func (s *BaseGoogleSQLParserListener) EnterNumeric_literal_prefix(ctx *Numeric_literal_prefixContext) { +} + +// ExitNumeric_literal_prefix is called when production numeric_literal_prefix is exited. +func (s *BaseGoogleSQLParserListener) ExitNumeric_literal_prefix(ctx *Numeric_literal_prefixContext) { +} + +// EnterInteger_literal is called when production integer_literal is entered. +func (s *BaseGoogleSQLParserListener) EnterInteger_literal(ctx *Integer_literalContext) {} + +// ExitInteger_literal is called when production integer_literal is exited. +func (s *BaseGoogleSQLParserListener) ExitInteger_literal(ctx *Integer_literalContext) {} + +// EnterBytes_literal is called when production bytes_literal is entered. +func (s *BaseGoogleSQLParserListener) EnterBytes_literal(ctx *Bytes_literalContext) {} + +// ExitBytes_literal is called when production bytes_literal is exited. +func (s *BaseGoogleSQLParserListener) ExitBytes_literal(ctx *Bytes_literalContext) {} + +// EnterNull_literal is called when production null_literal is entered. +func (s *BaseGoogleSQLParserListener) EnterNull_literal(ctx *Null_literalContext) {} + +// ExitNull_literal is called when production null_literal is exited. +func (s *BaseGoogleSQLParserListener) ExitNull_literal(ctx *Null_literalContext) {} + +// EnterBoolean_literal is called when production boolean_literal is entered. +func (s *BaseGoogleSQLParserListener) EnterBoolean_literal(ctx *Boolean_literalContext) {} + +// ExitBoolean_literal is called when production boolean_literal is exited. +func (s *BaseGoogleSQLParserListener) ExitBoolean_literal(ctx *Boolean_literalContext) {} + +// EnterString_literal is called when production string_literal is entered. +func (s *BaseGoogleSQLParserListener) EnterString_literal(ctx *String_literalContext) {} + +// ExitString_literal is called when production string_literal is exited. +func (s *BaseGoogleSQLParserListener) ExitString_literal(ctx *String_literalContext) {} + +// EnterString_literal_component is called when production string_literal_component is entered. +func (s *BaseGoogleSQLParserListener) EnterString_literal_component(ctx *String_literal_componentContext) { +} + +// ExitString_literal_component is called when production string_literal_component is exited. +func (s *BaseGoogleSQLParserListener) ExitString_literal_component(ctx *String_literal_componentContext) { +} + +// EnterBytes_literal_component is called when production bytes_literal_component is entered. +func (s *BaseGoogleSQLParserListener) EnterBytes_literal_component(ctx *Bytes_literal_componentContext) { +} + +// ExitBytes_literal_component is called when production bytes_literal_component is exited. +func (s *BaseGoogleSQLParserListener) ExitBytes_literal_component(ctx *Bytes_literal_componentContext) { +} diff --git a/googlesql/googlesqlparser_base_visitor.go b/googlesql/googlesqlparser_base_visitor.go new file mode 100644 index 0000000..105b343 --- /dev/null +++ b/googlesql/googlesqlparser_base_visitor.go @@ -0,0 +1,2508 @@ +// Code generated from GoogleSQLParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package googlesql // GoogleSQLParser +import "github.com/antlr4-go/antlr/v4" + +type BaseGoogleSQLParserVisitor struct { + *antlr.BaseParseTreeVisitor +} + +func (v *BaseGoogleSQLParserVisitor) VisitRoot(ctx *RootContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitStmts(ctx *StmtsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitUnterminated_sql_statement(ctx *Unterminated_sql_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSql_statement_body(ctx *Sql_statement_bodyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGql_statement(ctx *Gql_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_operation_block(ctx *Graph_operation_blockContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_composite_query_block(ctx *Graph_composite_query_blockContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_composite_query_prefix(ctx *Graph_composite_query_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_set_operation_metadata(ctx *Graph_set_operation_metadataContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_linear_query_operation(ctx *Graph_linear_query_operationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_linear_operator_list(ctx *Graph_linear_operator_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_linear_operator(ctx *Graph_linear_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_sample_clause(ctx *Graph_sample_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_graph_sample_clause_suffix(ctx *Opt_graph_sample_clause_suffixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_for_operator(ctx *Graph_for_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_with_offset_and_alias_with_required_as(ctx *Opt_with_offset_and_alias_with_required_asContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_with_operator(ctx *Graph_with_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_page_operator(ctx *Graph_page_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_order_by_operator(ctx *Graph_order_by_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_filter_operator(ctx *Graph_filter_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_let_operator(ctx *Graph_let_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_let_variable_definition_list(ctx *Graph_let_variable_definition_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_let_variable_definition(ctx *Graph_let_variable_definitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_optional_match_operator(ctx *Graph_optional_match_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_match_operator(ctx *Graph_match_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_pattern(ctx *Graph_patternContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_path_pattern_list(ctx *Graph_path_pattern_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_path_pattern(ctx *Graph_path_patternContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_path_pattern_expr(ctx *Graph_path_pattern_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_path_factor(ctx *Graph_path_factorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_quantified_path_primary(ctx *Graph_quantified_path_primaryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_path_primary(ctx *Graph_path_primaryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_parenthesized_path_pattern(ctx *Graph_parenthesized_path_patternContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_element_pattern(ctx *Graph_element_patternContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_edge_pattern(ctx *Graph_edge_patternContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_node_pattern(ctx *Graph_node_patternContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_element_pattern_filler(ctx *Graph_element_pattern_fillerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_property_specification(ctx *Graph_property_specificationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_property_name_and_value(ctx *Graph_property_name_and_valueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_is_label_expression(ctx *Opt_is_label_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitLabel_expression(ctx *Label_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitLabel_primary(ctx *Label_primaryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitParenthesized_label_expression(ctx *Parenthesized_label_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_graph_element_identifier(ctx *Opt_graph_element_identifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_graph_path_mode_prefix(ctx *Opt_graph_path_mode_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPath_or_paths(ctx *Path_or_pathsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_graph_path_mode(ctx *Opt_graph_path_modeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_graph_search_prefix(ctx *Opt_graph_search_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_path_variable_assignment(ctx *Opt_path_variable_assignmentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_identifier(ctx *Graph_identifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_return_operator(ctx *Graph_return_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_page_clause(ctx *Graph_page_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_order_by_clause(ctx *Graph_order_by_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_ordering_expression(ctx *Graph_ordering_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_graph_asc_or_desc(ctx *Opt_graph_asc_or_descContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_return_item_list(ctx *Graph_return_item_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGraph_return_item(ctx *Graph_return_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitUndrop_statement(ctx *Undrop_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitModule_statement(ctx *Module_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitImport_statement(ctx *Import_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_as_or_into_alias(ctx *Opt_as_or_into_aliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPath_expression_or_string(ctx *Path_expression_or_stringContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitImport_type(ctx *Import_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCall_statement(ctx *Call_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitDrop_statement(ctx *Drop_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_drop_mode(ctx *Opt_drop_modeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitDrop_all_row_access_policies_statement(ctx *Drop_all_row_access_policies_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitShow_statement(ctx *Show_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_like_string_literal(ctx *Opt_like_string_literalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitShow_target(ctx *Show_targetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitRename_statement(ctx *Rename_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitRevoke_statement(ctx *Revoke_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGrant_statement(ctx *Grant_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPrivileges(ctx *PrivilegesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitExport_metadata_statement(ctx *Export_metadata_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitExport_model_statement(ctx *Export_model_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitExport_data_statement(ctx *Export_data_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitExport_data_no_query(ctx *Export_data_no_queryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitExplain_statement(ctx *Explain_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitExecute_immediate(ctx *Execute_immediateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_execute_into_clause(ctx *Opt_execute_into_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_execute_using_clause(ctx *Opt_execute_using_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitExecute_using_argument_list(ctx *Execute_using_argument_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitExecute_using_argument(ctx *Execute_using_argumentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitDescribe_statement(ctx *Describe_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitDescribe_info(ctx *Describe_infoContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_from_path_expression(ctx *Opt_from_path_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitDescribe_keyword(ctx *Describe_keywordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitDefine_table_statement(ctx *Define_table_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCreate_entity_statement(ctx *Create_entity_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_generic_entity_body(ctx *Opt_generic_entity_bodyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCreate_view_statement(ctx *Create_view_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitQuery_or_replica_source(ctx *Query_or_replica_sourceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitColumn_with_options_list(ctx *Column_with_options_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitColumn_with_options(ctx *Column_with_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCreate_table_statement(ctx *Create_table_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_ttl_clause(ctx *Opt_ttl_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_copy_table(ctx *Opt_copy_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCopy_data_source(ctx *Copy_data_sourceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_clone_table(ctx *Opt_clone_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_spanner_table_options(ctx *Opt_spanner_table_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_spanner_interleave_in_parent_clause(ctx *Opt_spanner_interleave_in_parent_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSpanner_primary_key(ctx *Spanner_primary_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCreate_table_function_statement(ctx *Create_table_function_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_as_query_or_string(ctx *Opt_as_query_or_stringContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitUnordered_language_options(ctx *Unordered_language_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_function_parameters(ctx *Opt_function_parametersContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCreate_snapshot_statement(ctx *Create_snapshot_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCreate_external_schema_statement(ctx *Create_external_schema_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCreate_schema_statement(ctx *Create_schema_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCreate_property_graph_statement(ctx *Create_property_graph_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_edge_table_clause(ctx *Opt_edge_table_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitElement_table_list(ctx *Element_table_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitElement_table_definition(ctx *Element_table_definitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_label_and_properties_clause(ctx *Opt_label_and_properties_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitLabel_and_properties_list(ctx *Label_and_properties_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitLabel_and_properties(ctx *Label_and_propertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitProperties_clause(ctx *Properties_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitDerived_property_list(ctx *Derived_property_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitDerived_property(ctx *Derived_propertyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_except_column_list(ctx *Opt_except_column_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitProperties_all_columns(ctx *Properties_all_columnsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_dest_node_table_clause(ctx *Opt_dest_node_table_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_source_node_table_clause(ctx *Opt_source_node_table_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_key_clause(ctx *Opt_key_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCreate_model_statement(ctx *Create_model_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_input_output_clause(ctx *Opt_input_output_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_transform_clause(ctx *Opt_transform_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_as_query_or_aliased_query_list(ctx *Opt_as_query_or_aliased_query_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitAliased_query_list(ctx *Aliased_query_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitAs_query(ctx *As_queryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCreate_external_table_function_statement(ctx *Create_external_table_function_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCreate_external_table_statement(ctx *Create_external_table_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_default_collate_clause(ctx *Opt_default_collate_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_like_path_expression(ctx *Opt_like_path_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCreate_row_access_policy_statement(ctx *Create_row_access_policy_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitFilter_using_clause(ctx *Filter_using_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCreate_row_access_policy_grant_to_clause(ctx *Create_row_access_policy_grant_to_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCreate_privilege_restriction_statement(ctx *Create_privilege_restriction_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitRestrict_to_clause(ctx *Restrict_to_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPossibly_empty_grantee_list(ctx *Possibly_empty_grantee_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCreate_index_statement(ctx *Create_index_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_create_index_statement_suffix(ctx *Opt_create_index_statement_suffixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSpanner_index_interleave_clause(ctx *Spanner_index_interleave_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitIndex_storing_list(ctx *Index_storing_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitIndex_storing_expression_list(ctx *Index_storing_expression_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitIndex_order_by_and_options(ctx *Index_order_by_and_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitIndex_all_columns(ctx *Index_all_columnsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_with_column_options(ctx *Opt_with_column_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitAll_column_column_options(ctx *All_column_column_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitColumn_ordering_and_options_expr(ctx *Column_ordering_and_options_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitIndex_unnest_expression_list(ctx *Index_unnest_expression_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitUnnest_expression_with_opt_alias_and_offset(ctx *Unnest_expression_with_opt_alias_and_offsetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOn_path_expression(ctx *On_path_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitIndex_type(ctx *Index_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_spanner_null_filtered(ctx *Opt_spanner_null_filteredContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCreate_procedure_statement(ctx *Create_procedure_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitBegin_end_block_or_language_as_code(ctx *Begin_end_block_or_language_as_codeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitBegin_end_block(ctx *Begin_end_blockContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_exception_handler(ctx *Opt_exception_handlerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitStatement_list(ctx *Statement_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitUnterminated_non_empty_statement_list(ctx *Unterminated_non_empty_statement_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitUnterminated_statement(ctx *Unterminated_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitUnterminated_script_statement(ctx *Unterminated_script_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitLabel(ctx *LabelContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitUnterminated_unlabeled_script_statement(ctx *Unterminated_unlabeled_script_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitFor_in_statement(ctx *For_in_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitRepeat_statement(ctx *Repeat_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitUntil_clause(ctx *Until_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitLoop_statement(ctx *Loop_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitWhile_statement(ctx *While_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitRaise_statement(ctx *Raise_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitReturn_statement(ctx *Return_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitContinue_statement(ctx *Continue_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitVariable_declaration(ctx *Variable_declarationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitBreak_statement(ctx *Break_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCase_statement(ctx *Case_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitWhen_then_clauses(ctx *When_then_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitIf_statement(ctx *If_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitElseif_clauses(ctx *Elseif_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_else(ctx *Opt_elseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_as_code(ctx *Opt_as_codeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_external_security_clause(ctx *Opt_external_security_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitExternal_security_clause_kind(ctx *External_security_clause_kindContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitProcedure_parameters(ctx *Procedure_parametersContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitProcedure_parameter(ctx *Procedure_parameterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitProcedure_parameter_termination(ctx *Procedure_parameter_terminationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_procedure_parameter_mode(ctx *Opt_procedure_parameter_modeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCreate_function_statement(ctx *Create_function_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_determinism_level(ctx *Opt_determinism_levelContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_sql_security_clause(ctx *Opt_sql_security_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSql_security_clause_kind(ctx *Sql_security_clause_kindContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitAs_sql_function_body_or_string(ctx *As_sql_function_body_or_stringContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSql_function_body(ctx *Sql_function_bodyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitUnordered_options_body(ctx *Unordered_options_bodyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_language_or_remote_with_connection(ctx *Opt_language_or_remote_with_connectionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitLanguage(ctx *LanguageContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitRemote_with_connection_clause(ctx *Remote_with_connection_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitWith_connection_clause(ctx *With_connection_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_function_returns(ctx *Opt_function_returnsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_returns(ctx *Opt_returnsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitFunction_declaration(ctx *Function_declarationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitFunction_parameters(ctx *Function_parametersContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitFunction_parameter(ctx *Function_parameterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_not_aggregate(ctx *Opt_not_aggregateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_default_expression(ctx *Opt_default_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitType_or_tvf_schema(ctx *Type_or_tvf_schemaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTvf_schema(ctx *Tvf_schemaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTvf_schema_column(ctx *Tvf_schema_columnContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTemplated_parameter_type(ctx *Templated_parameter_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTemplated_parameter_kind(ctx *Templated_parameter_kindContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_aggregate(ctx *Opt_aggregateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCreate_database_statement(ctx *Create_database_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCreate_connection_statement(ctx *Create_connection_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCreate_constant_statement(ctx *Create_constant_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_or_replace(ctx *Opt_or_replaceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_create_scope(ctx *Opt_create_scopeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitRun_batch_statement(ctx *Run_batch_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitAbort_batch_statement(ctx *Abort_batch_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitStart_batch_statement(ctx *Start_batch_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitRollback_statement(ctx *Rollback_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCommit_statement(ctx *Commit_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSet_statement(ctx *Set_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitIdentifier_list(ctx *Identifier_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitBegin_statement(ctx *Begin_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitBegin_transaction_keywords(ctx *Begin_transaction_keywordsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTransaction_mode_list(ctx *Transaction_mode_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTransaction_mode(ctx *Transaction_modeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTruncate_statement(ctx *Truncate_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitMerge_statement(ctx *Merge_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitMerge_source(ctx *Merge_sourceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitMerge_when_clause(ctx *Merge_when_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitMerge_action(ctx *Merge_actionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitMerge_insert_value_list_or_source_row(ctx *Merge_insert_value_list_or_source_rowContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitBy_target(ctx *By_targetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_and_expression(ctx *Opt_and_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitStatement_level_hint(ctx *Statement_level_hintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitQuery_statement(ctx *Query_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitDml_statement(ctx *Dml_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitUpdate_statement(ctx *Update_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitDelete_statement(ctx *Delete_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitInsert_statement(ctx *Insert_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOn_conflict_clause(ctx *On_conflict_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_where_expression(ctx *Opt_where_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_conflict_target(ctx *Opt_conflict_targetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitUpdate_item_list(ctx *Update_item_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitUpdate_item(ctx *Update_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitUpdate_set_value(ctx *Update_set_valueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitNested_dml_statement(ctx *Nested_dml_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitInsert_values_list_or_table_clause(ctx *Insert_values_list_or_table_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTable_clause_unreversed(ctx *Table_clause_unreversedContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTable_clause_no_keyword(ctx *Table_clause_no_keywordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_returning_clause(ctx *Opt_returning_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_assert_rows_modified(ctx *Opt_assert_rows_modifiedContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitInsert_values_or_query(ctx *Insert_values_or_queryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitInsert_values_list(ctx *Insert_values_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitInsert_values_row(ctx *Insert_values_rowContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitExpression_or_default(ctx *Expression_or_defaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitInsert_statement_prefix(ctx *Insert_statement_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitMaybe_dashed_generalized_path_expression(ctx *Maybe_dashed_generalized_path_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_into(ctx *Opt_intoContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_or_ignore_replace_update(ctx *Opt_or_ignore_replace_updateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitAlter_statement(ctx *Alter_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitAnalyze_statement(ctx *Analyze_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitAssert_statement(ctx *Assert_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitAux_load_data_statement(ctx *Aux_load_data_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitClone_data_statement(ctx *Clone_data_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitClone_data_source_list(ctx *Clone_data_source_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitClone_data_source(ctx *Clone_data_sourceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_external_table_with_clauses(ctx *Opt_external_table_with_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitWith_partition_columns_clause(ctx *With_partition_columns_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitAux_load_data_from_files_options_list(ctx *Aux_load_data_from_files_options_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCluster_by_clause_prefix_no_hint(ctx *Cluster_by_clause_prefix_no_hintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitLoad_data_partitions_clause(ctx *Load_data_partitions_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitMaybe_dashed_path_expression_with_scope(ctx *Maybe_dashed_path_expression_with_scopeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTable_element_list(ctx *Table_element_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTable_element(ctx *Table_elementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTable_constraint_definition(ctx *Table_constraint_definitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitAppend_or_overwrite(ctx *Append_or_overwriteContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_description(ctx *Opt_descriptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTable_and_column_info_list(ctx *Table_and_column_info_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTable_and_column_info(ctx *Table_and_column_infoContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitRow_access_policy_alter_action_list(ctx *Row_access_policy_alter_action_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitRow_access_policy_alter_action(ctx *Row_access_policy_alter_actionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGrant_to_clause(ctx *Grant_to_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGrantee_list(ctx *Grantee_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPrivilege_list(ctx *Privilege_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPrivilege(ctx *PrivilegeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPath_expression_list_with_parens(ctx *Path_expression_list_with_parensContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPrivilege_name(ctx *Privilege_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGeneric_entity_type(ctx *Generic_entity_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGeneric_entity_type_unchecked(ctx *Generic_entity_type_uncheckedContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSchema_object_kind(ctx *Schema_object_kindContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitAlter_action_list(ctx *Alter_action_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitAlter_action(ctx *Alter_actionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSpanner_set_on_delete_action(ctx *Spanner_set_on_delete_actionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSpanner_alter_column_action(ctx *Spanner_alter_column_actionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSpanner_generated_or_default(ctx *Spanner_generated_or_defaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGeneric_sub_entity_type(ctx *Generic_sub_entity_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSub_entity_type_identifier(ctx *Sub_entity_type_identifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitFill_using_expression(ctx *Fill_using_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitColumn_position(ctx *Column_positionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTable_column_definition(ctx *Table_column_definitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitColumn_attributes(ctx *Column_attributesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitColumn_attribute(ctx *Column_attributeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPrimary_key_column_attribute(ctx *Primary_key_column_attributeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitForeign_key_column_attribute(ctx *Foreign_key_column_attributeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitHidden_column_attribute(ctx *Hidden_column_attributeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_constraint_identity(ctx *Opt_constraint_identityContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTable_column_schema(ctx *Table_column_schemaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_column_info(ctx *Opt_column_infoContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitInvalid_generated_column(ctx *Invalid_generated_columnContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitInvalid_default_column(ctx *Invalid_default_columnContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitDefault_column_info(ctx *Default_column_infoContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGenerated_column_info(ctx *Generated_column_infoContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitIdentity_column_info(ctx *Identity_column_infoContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_start_with(ctx *Opt_start_withContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_increment_by(ctx *Opt_increment_byContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_maxvalue(ctx *Opt_maxvalueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_minvalue(ctx *Opt_minvalueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_cycle(ctx *Opt_cycleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSigned_numeric_literal(ctx *Signed_numeric_literalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitStored_mode(ctx *Stored_modeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGenerated_mode(ctx *Generated_modeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitColumn_schema_inner(ctx *Column_schema_innerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitRaw_column_schema_inner(ctx *Raw_column_schema_innerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitRange_column_schema_inner(ctx *Range_column_schema_innerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitStruct_column_schema_inner(ctx *Struct_column_schema_innerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitStruct_column_field(ctx *Struct_column_fieldContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSimple_column_schema_inner(ctx *Simple_column_schema_innerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitArray_column_schema_inner(ctx *Array_column_schema_innerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitField_schema(ctx *Field_schemaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_field_attributes(ctx *Opt_field_attributesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitNot_null_column_attribute(ctx *Not_null_column_attributeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPrimary_key_or_table_constraint_spec(ctx *Primary_key_or_table_constraint_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_if_not_exists(ctx *Opt_if_not_existsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPrimary_key_spec(ctx *Primary_key_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPrimary_key_element_list(ctx *Primary_key_element_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPrimary_key_element(ctx *Primary_key_elementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTable_constraint_spec(ctx *Table_constraint_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitForeign_key_reference(ctx *Foreign_key_referenceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_foreign_key_action(ctx *Opt_foreign_key_actionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitForeign_key_on_update(ctx *Foreign_key_on_updateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitForeign_key_on_delete(ctx *Foreign_key_on_deleteContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitForeign_key_action(ctx *Foreign_key_actionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_foreign_key_match(ctx *Opt_foreign_key_matchContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitForeign_key_match_mode(ctx *Foreign_key_match_modeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitColumn_list(ctx *Column_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_options_list(ctx *Opt_options_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitConstraint_enforcement(ctx *Constraint_enforcementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGeneric_entity_body(ctx *Generic_entity_bodyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_if_exists(ctx *Opt_if_existsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTable_or_table_function(ctx *Table_or_table_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitQuery(ctx *QueryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitQuery_without_pipe_operators(ctx *Query_without_pipe_operatorsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitBad_keyword_after_from_query(ctx *Bad_keyword_after_from_queryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitBad_keyword_after_from_query_allows_parens(ctx *Bad_keyword_after_from_query_allows_parensContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitWith_clause_with_trailing_comma(ctx *With_clause_with_trailing_commaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSelect_or_from_keyword(ctx *Select_or_from_keywordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitQuery_primary_or_set_operation(ctx *Query_primary_or_set_operationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitQuery_set_operation(ctx *Query_set_operationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitQuery_set_operation_prefix(ctx *Query_set_operation_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitQuery_set_operation_item(ctx *Query_set_operation_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitQuery_primary(ctx *Query_primaryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSet_operation_metadata(ctx *Set_operation_metadataContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_column_match_suffix(ctx *Opt_column_match_suffixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_strict(ctx *Opt_strictContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitAll_or_distinct(ctx *All_or_distinctContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitQuery_set_operation_type(ctx *Query_set_operation_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_corresponding_outer_mode(ctx *Opt_corresponding_outer_modeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_outer(ctx *Opt_outerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitWith_clause(ctx *With_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitAliased_query(ctx *Aliased_queryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_aliased_query_modifiers(ctx *Opt_aliased_query_modifiersContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitRecursion_depth_modifier(ctx *Recursion_depth_modifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPossibly_unbounded_int_literal_or_parameter(ctx *Possibly_unbounded_int_literal_or_parameterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitInt_literal_or_parameter(ctx *Int_literal_or_parameterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOrder_by_clause(ctx *Order_by_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOrder_by_clause_prefix(ctx *Order_by_clause_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOrdering_expression(ctx *Ordering_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSelect(ctx *SelectContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_clauses_following_from(ctx *Opt_clauses_following_fromContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_clauses_following_where(ctx *Opt_clauses_following_whereContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_clauses_following_group_by(ctx *Opt_clauses_following_group_byContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitWindow_clause(ctx *Window_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitWindow_clause_prefix(ctx *Window_clause_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitWindow_definition(ctx *Window_definitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitWhere_clause(ctx *Where_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitHaving_clause(ctx *Having_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGroup_by_clause(ctx *Group_by_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGroup_by_all(ctx *Group_by_allContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSelect_clause(ctx *Select_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_select_as_clause(ctx *Opt_select_as_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_select_with(ctx *Opt_select_withContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitFrom_clause(ctx *From_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitFrom_clause_contents(ctx *From_clause_contentsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitFrom_clause_contents_suffix(ctx *From_clause_contents_suffixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTable_primary(ctx *Table_primaryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTvf_with_suffixes(ctx *Tvf_with_suffixesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPivot_or_unpivot_clause_and_aliases(ctx *Pivot_or_unpivot_clause_and_aliasesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitAs_alias(ctx *As_aliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSample_clause(ctx *Sample_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_sample_clause_suffix(ctx *Opt_sample_clause_suffixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitRepeatable_clause(ctx *Repeatable_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPossibly_cast_int_literal_or_parameter(ctx *Possibly_cast_int_literal_or_parameterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCast_int_literal_or_parameter(ctx *Cast_int_literal_or_parameterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSample_size(ctx *Sample_sizeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSample_size_value(ctx *Sample_size_valueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSample_size_unit(ctx *Sample_size_unitContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPartition_by_clause_prefix_no_hint(ctx *Partition_by_clause_prefix_no_hintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitMatch_recognize_clause(ctx *Match_recognize_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitRow_pattern_expr(ctx *Row_pattern_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitRow_pattern_concatenation(ctx *Row_pattern_concatenationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitRow_pattern_factor(ctx *Row_pattern_factorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSelect_list_prefix_with_as_aliases(ctx *Select_list_prefix_with_as_aliasesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSelect_column_expr_with_as_alias(ctx *Select_column_expr_with_as_aliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTable_subquery(ctx *Table_subqueryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitJoin(ctx *JoinContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitJoin_item(ctx *Join_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOn_or_using_clause_list(ctx *On_or_using_clause_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOn_or_using_clause(ctx *On_or_using_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitUsing_clause(ctx *Using_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitJoin_hint(ctx *Join_hintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTable_path_expression(ctx *Table_path_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_at_system_time(ctx *Opt_at_system_timeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_with_offset_and_alias(ctx *Opt_with_offset_and_aliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_pivot_or_unpivot_clause_and_alias(ctx *Opt_pivot_or_unpivot_clause_and_aliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTable_path_expression_base(ctx *Table_path_expression_baseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitMaybe_slashed_or_dashed_path_expression(ctx *Maybe_slashed_or_dashed_path_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitMaybe_dashed_path_expression(ctx *Maybe_dashed_path_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitDashed_path_expression(ctx *Dashed_path_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitDashed_identifier(ctx *Dashed_identifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSlashed_identifier(ctx *Slashed_identifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitIdentifier_or_integer(ctx *Identifier_or_integerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSlashed_identifier_separator(ctx *Slashed_identifier_separatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSlashed_path_expression(ctx *Slashed_path_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitUnnest_expression(ctx *Unnest_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitUnnest_expression_prefix(ctx *Unnest_expression_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_array_zip_mode(ctx *Opt_array_zip_modeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitExpression_with_opt_alias(ctx *Expression_with_opt_aliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTvf_prefix(ctx *Tvf_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTvf_argument(ctx *Tvf_argumentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitConnection_clause(ctx *Connection_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPath_expression_or_default(ctx *Path_expression_or_defaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitDescriptor_argument(ctx *Descriptor_argumentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitDescriptor_column_list(ctx *Descriptor_column_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitDescriptor_column(ctx *Descriptor_columnContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTable_clause(ctx *Table_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitModel_clause(ctx *Model_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitQualify_clause_nonreserved(ctx *Qualify_clause_nonreservedContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitUnpivot_clause(ctx *Unpivot_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitUnpivot_in_item_list(ctx *Unpivot_in_item_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitUnpivot_in_item_list_prefix(ctx *Unpivot_in_item_list_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitUnpivot_in_item(ctx *Unpivot_in_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_as_string_or_integer(ctx *Opt_as_string_or_integerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPath_expression_list_with_opt_parens(ctx *Path_expression_list_with_opt_parensContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPath_expression_list(ctx *Path_expression_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitUnpivot_nulls_filter(ctx *Unpivot_nulls_filterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPivot_clause(ctx *Pivot_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPivot_expression_list(ctx *Pivot_expression_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPivot_expression(ctx *Pivot_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPivot_value_list(ctx *Pivot_value_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPivot_value(ctx *Pivot_valueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTvf_prefix_no_args(ctx *Tvf_prefix_no_argsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitJoin_type(ctx *Join_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_natural(ctx *Opt_naturalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOn_clause(ctx *On_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSelect_list(ctx *Select_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSelect_list_item(ctx *Select_list_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSelect_column_star(ctx *Select_column_starContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSelect_column_expr(ctx *Select_column_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSelect_column_dot_star(ctx *Select_column_dot_starContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitStar_modifiers(ctx *Star_modifiersContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitStar_except_list(ctx *Star_except_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitStar_replace_list(ctx *Star_replace_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitStar_replace_item(ctx *Star_replace_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitExpression(ctx *ExpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitExpression_higher_prec_than_and(ctx *Expression_higher_prec_than_andContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitExpression_maybe_parenthesized_not_a_query(ctx *Expression_maybe_parenthesized_not_a_queryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitParenthesized_in_rhs(ctx *Parenthesized_in_rhsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitUnary_operator(ctx *Unary_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitComparative_operator(ctx *Comparative_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitShift_operator(ctx *Shift_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitAdditive_operator(ctx *Additive_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitMultiplicative_operator(ctx *Multiplicative_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitIs_operator(ctx *Is_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitBetween_operator(ctx *Between_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitIn_operator(ctx *In_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitDistinct_operator(ctx *Distinct_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitParenthesized_query(ctx *Parenthesized_queryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitParenthesized_expression_not_a_query(ctx *Parenthesized_expression_not_a_queryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitParenthesized_anysomeall_list_in_rhs(ctx *Parenthesized_anysomeall_list_in_rhsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitAnd_expression(ctx *And_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitIn_list_two_or_more_prefix(ctx *In_list_two_or_more_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitAny_some_all(ctx *Any_some_allContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitLike_operator(ctx *Like_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitExpression_subquery_with_keyword(ctx *Expression_subquery_with_keywordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitStruct_constructor(ctx *Struct_constructorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitStruct_constructor_prefix_with_keyword(ctx *Struct_constructor_prefix_with_keywordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitStruct_constructor_arg(ctx *Struct_constructor_argContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitStruct_constructor_prefix_without_keyword(ctx *Struct_constructor_prefix_without_keywordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitStruct_constructor_prefix_with_keyword_no_arg(ctx *Struct_constructor_prefix_with_keyword_no_argContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitInterval_expression(ctx *Interval_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitFunction_call_expression_with_clauses(ctx *Function_call_expression_with_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitFunction_call_expression_with_clauses_suffix(ctx *Function_call_expression_with_clauses_suffixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOver_clause(ctx *Over_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitWindow_specification(ctx *Window_specificationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_window_frame_clause(ctx *Opt_window_frame_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitWindow_frame_bound(ctx *Window_frame_boundContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPreceding_or_following(ctx *Preceding_or_followingContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitFrame_unit(ctx *Frame_unitContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPartition_by_clause(ctx *Partition_by_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPartition_by_clause_prefix(ctx *Partition_by_clause_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitWith_group_rows(ctx *With_group_rowsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitWith_report_modifier(ctx *With_report_modifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitClamped_between_modifier(ctx *Clamped_between_modifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitWith_report_format(ctx *With_report_formatContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOptions_list(ctx *Options_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOptions_list_prefix(ctx *Options_list_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOptions_entry(ctx *Options_entryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitExpression_or_proto(ctx *Expression_or_protoContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOptions_assignment_operator(ctx *Options_assignment_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_null_handling_modifier(ctx *Opt_null_handling_modifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitFunction_call_argument(ctx *Function_call_argumentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSequence_arg(ctx *Sequence_argContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitNamed_argument(ctx *Named_argumentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitLambda_argument(ctx *Lambda_argumentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitLambda_argument_list(ctx *Lambda_argument_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitLimit_offset_clause(ctx *Limit_offset_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_having_or_group_by_modifier(ctx *Opt_having_or_group_by_modifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGroup_by_clause_prefix(ctx *Group_by_clause_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGroup_by_preamble(ctx *Group_by_preambleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_and_order(ctx *Opt_and_orderContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitHint(ctx *HintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitHint_with_body(ctx *Hint_with_bodyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitHint_with_body_prefix(ctx *Hint_with_body_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitHint_entry(ctx *Hint_entryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitIdentifier_in_hints(ctx *Identifier_in_hintsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitExtra_identifier_in_hints_name(ctx *Extra_identifier_in_hints_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGrouping_item(ctx *Grouping_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGrouping_set_list(ctx *Grouping_set_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGrouping_set(ctx *Grouping_setContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCube_list(ctx *Cube_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitRollup_list(ctx *Rollup_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_as_alias_with_required_as(ctx *Opt_as_alias_with_required_asContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_grouping_item_order(ctx *Opt_grouping_item_orderContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_selection_item_order(ctx *Opt_selection_item_orderContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitAsc_or_desc(ctx *Asc_or_descContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitNull_order(ctx *Null_orderContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitFunction_name_from_keyword(ctx *Function_name_from_keywordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitReplace_fields_expression(ctx *Replace_fields_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitReplace_fields_prefix(ctx *Replace_fields_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitReplace_fields_arg(ctx *Replace_fields_argContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGeneralized_path_expression(ctx *Generalized_path_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitGeneralized_extension_path(ctx *Generalized_extension_pathContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitWith_expression(ctx *With_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitWith_expression_variable_prefix(ctx *With_expression_variable_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitWith_expression_variable(ctx *With_expression_variableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitExtract_expression(ctx *Extract_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitExtract_expression_base(ctx *Extract_expression_baseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_format(ctx *Opt_formatContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_at_time_zone(ctx *Opt_at_time_zoneContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCast_expression(ctx *Cast_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCase_expression(ctx *Case_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCase_expression_prefix(ctx *Case_expression_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCase_value_expression_prefix(ctx *Case_value_expression_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCase_no_value_expression_prefix(ctx *Case_no_value_expression_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitStruct_braced_constructor(ctx *Struct_braced_constructorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitBraced_new_constructor(ctx *Braced_new_constructorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitBraced_constructor(ctx *Braced_constructorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitBraced_constructor_start(ctx *Braced_constructor_startContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitBraced_constructor_prefix(ctx *Braced_constructor_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitBraced_constructor_field(ctx *Braced_constructor_fieldContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitBraced_constructor_lhs(ctx *Braced_constructor_lhsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitBraced_constructor_field_value(ctx *Braced_constructor_field_valueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitBraced_constructor_extension(ctx *Braced_constructor_extensionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitNew_constructor(ctx *New_constructorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitNew_constructor_prefix(ctx *New_constructor_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitNew_constructor_prefix_no_arg(ctx *New_constructor_prefix_no_argContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitNew_constructor_arg(ctx *New_constructor_argContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitArray_constructor(ctx *Array_constructorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitArray_constructor_prefix(ctx *Array_constructor_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitArray_constructor_prefix_no_expressions(ctx *Array_constructor_prefix_no_expressionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitRange_literal(ctx *Range_literalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitRange_type(ctx *Range_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitType(ctx *TypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCollate_clause(ctx *Collate_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitString_literal_or_parameter(ctx *String_literal_or_parameterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitSystem_variable_expression(ctx *System_variable_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitParameter_expression(ctx *Parameter_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitNamed_parameter_expression(ctx *Named_parameter_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitOpt_type_parameters(ctx *Opt_type_parametersContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitType_parameters_prefix(ctx *Type_parameters_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitType_parameter(ctx *Type_parameterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitRaw_type(ctx *Raw_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitMap_type(ctx *Map_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitFunction_type(ctx *Function_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitFunction_type_prefix(ctx *Function_type_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitType_name(ctx *Type_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitPath_expression(ctx *Path_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitIdentifier(ctx *IdentifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitKeyword_as_identifier(ctx *Keyword_as_identifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitCommon_keyword_as_identifier(ctx *Common_keyword_as_identifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitToken_identifier(ctx *Token_identifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitStruct_type(ctx *Struct_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitStruct_type_prefix(ctx *Struct_type_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitStruct_field(ctx *Struct_fieldContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitArray_type(ctx *Array_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTemplate_type_open(ctx *Template_type_openContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitTemplate_type_close(ctx *Template_type_closeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitDate_or_time_literal(ctx *Date_or_time_literalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitDate_or_time_literal_kind(ctx *Date_or_time_literal_kindContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitFloating_point_literal(ctx *Floating_point_literalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitJson_literal(ctx *Json_literalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitBignumeric_literal(ctx *Bignumeric_literalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitBignumeric_literal_prefix(ctx *Bignumeric_literal_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitNumeric_literal(ctx *Numeric_literalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitNumeric_literal_prefix(ctx *Numeric_literal_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitInteger_literal(ctx *Integer_literalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitBytes_literal(ctx *Bytes_literalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitNull_literal(ctx *Null_literalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitBoolean_literal(ctx *Boolean_literalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitString_literal(ctx *String_literalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitString_literal_component(ctx *String_literal_componentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseGoogleSQLParserVisitor) VisitBytes_literal_component(ctx *Bytes_literal_componentContext) interface{} { + return v.VisitChildren(ctx) +} diff --git a/googlesql/googlesqlparser_listener.go b/googlesql/googlesqlparser_listener.go new file mode 100644 index 0000000..4fd275b --- /dev/null +++ b/googlesql/googlesqlparser_listener.go @@ -0,0 +1,3759 @@ +// Code generated from GoogleSQLParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package googlesql // GoogleSQLParser +import "github.com/antlr4-go/antlr/v4" + +// GoogleSQLParserListener is a complete listener for a parse tree produced by GoogleSQLParser. +type GoogleSQLParserListener interface { + antlr.ParseTreeListener + + // EnterRoot is called when entering the root production. + EnterRoot(c *RootContext) + + // EnterStmts is called when entering the stmts production. + EnterStmts(c *StmtsContext) + + // EnterUnterminated_sql_statement is called when entering the unterminated_sql_statement production. + EnterUnterminated_sql_statement(c *Unterminated_sql_statementContext) + + // EnterSql_statement_body is called when entering the sql_statement_body production. + EnterSql_statement_body(c *Sql_statement_bodyContext) + + // EnterGql_statement is called when entering the gql_statement production. + EnterGql_statement(c *Gql_statementContext) + + // EnterGraph_operation_block is called when entering the graph_operation_block production. + EnterGraph_operation_block(c *Graph_operation_blockContext) + + // EnterGraph_composite_query_block is called when entering the graph_composite_query_block production. + EnterGraph_composite_query_block(c *Graph_composite_query_blockContext) + + // EnterGraph_composite_query_prefix is called when entering the graph_composite_query_prefix production. + EnterGraph_composite_query_prefix(c *Graph_composite_query_prefixContext) + + // EnterGraph_set_operation_metadata is called when entering the graph_set_operation_metadata production. + EnterGraph_set_operation_metadata(c *Graph_set_operation_metadataContext) + + // EnterGraph_linear_query_operation is called when entering the graph_linear_query_operation production. + EnterGraph_linear_query_operation(c *Graph_linear_query_operationContext) + + // EnterGraph_linear_operator_list is called when entering the graph_linear_operator_list production. + EnterGraph_linear_operator_list(c *Graph_linear_operator_listContext) + + // EnterGraph_linear_operator is called when entering the graph_linear_operator production. + EnterGraph_linear_operator(c *Graph_linear_operatorContext) + + // EnterGraph_sample_clause is called when entering the graph_sample_clause production. + EnterGraph_sample_clause(c *Graph_sample_clauseContext) + + // EnterOpt_graph_sample_clause_suffix is called when entering the opt_graph_sample_clause_suffix production. + EnterOpt_graph_sample_clause_suffix(c *Opt_graph_sample_clause_suffixContext) + + // EnterGraph_for_operator is called when entering the graph_for_operator production. + EnterGraph_for_operator(c *Graph_for_operatorContext) + + // EnterOpt_with_offset_and_alias_with_required_as is called when entering the opt_with_offset_and_alias_with_required_as production. + EnterOpt_with_offset_and_alias_with_required_as(c *Opt_with_offset_and_alias_with_required_asContext) + + // EnterGraph_with_operator is called when entering the graph_with_operator production. + EnterGraph_with_operator(c *Graph_with_operatorContext) + + // EnterGraph_page_operator is called when entering the graph_page_operator production. + EnterGraph_page_operator(c *Graph_page_operatorContext) + + // EnterGraph_order_by_operator is called when entering the graph_order_by_operator production. + EnterGraph_order_by_operator(c *Graph_order_by_operatorContext) + + // EnterGraph_filter_operator is called when entering the graph_filter_operator production. + EnterGraph_filter_operator(c *Graph_filter_operatorContext) + + // EnterGraph_let_operator is called when entering the graph_let_operator production. + EnterGraph_let_operator(c *Graph_let_operatorContext) + + // EnterGraph_let_variable_definition_list is called when entering the graph_let_variable_definition_list production. + EnterGraph_let_variable_definition_list(c *Graph_let_variable_definition_listContext) + + // EnterGraph_let_variable_definition is called when entering the graph_let_variable_definition production. + EnterGraph_let_variable_definition(c *Graph_let_variable_definitionContext) + + // EnterGraph_optional_match_operator is called when entering the graph_optional_match_operator production. + EnterGraph_optional_match_operator(c *Graph_optional_match_operatorContext) + + // EnterGraph_match_operator is called when entering the graph_match_operator production. + EnterGraph_match_operator(c *Graph_match_operatorContext) + + // EnterGraph_pattern is called when entering the graph_pattern production. + EnterGraph_pattern(c *Graph_patternContext) + + // EnterGraph_path_pattern_list is called when entering the graph_path_pattern_list production. + EnterGraph_path_pattern_list(c *Graph_path_pattern_listContext) + + // EnterGraph_path_pattern is called when entering the graph_path_pattern production. + EnterGraph_path_pattern(c *Graph_path_patternContext) + + // EnterGraph_path_pattern_expr is called when entering the graph_path_pattern_expr production. + EnterGraph_path_pattern_expr(c *Graph_path_pattern_exprContext) + + // EnterGraph_path_factor is called when entering the graph_path_factor production. + EnterGraph_path_factor(c *Graph_path_factorContext) + + // EnterGraph_quantified_path_primary is called when entering the graph_quantified_path_primary production. + EnterGraph_quantified_path_primary(c *Graph_quantified_path_primaryContext) + + // EnterGraph_path_primary is called when entering the graph_path_primary production. + EnterGraph_path_primary(c *Graph_path_primaryContext) + + // EnterGraph_parenthesized_path_pattern is called when entering the graph_parenthesized_path_pattern production. + EnterGraph_parenthesized_path_pattern(c *Graph_parenthesized_path_patternContext) + + // EnterGraph_element_pattern is called when entering the graph_element_pattern production. + EnterGraph_element_pattern(c *Graph_element_patternContext) + + // EnterGraph_edge_pattern is called when entering the graph_edge_pattern production. + EnterGraph_edge_pattern(c *Graph_edge_patternContext) + + // EnterGraph_node_pattern is called when entering the graph_node_pattern production. + EnterGraph_node_pattern(c *Graph_node_patternContext) + + // EnterGraph_element_pattern_filler is called when entering the graph_element_pattern_filler production. + EnterGraph_element_pattern_filler(c *Graph_element_pattern_fillerContext) + + // EnterGraph_property_specification is called when entering the graph_property_specification production. + EnterGraph_property_specification(c *Graph_property_specificationContext) + + // EnterGraph_property_name_and_value is called when entering the graph_property_name_and_value production. + EnterGraph_property_name_and_value(c *Graph_property_name_and_valueContext) + + // EnterOpt_is_label_expression is called when entering the opt_is_label_expression production. + EnterOpt_is_label_expression(c *Opt_is_label_expressionContext) + + // EnterLabel_expression is called when entering the label_expression production. + EnterLabel_expression(c *Label_expressionContext) + + // EnterLabel_primary is called when entering the label_primary production. + EnterLabel_primary(c *Label_primaryContext) + + // EnterParenthesized_label_expression is called when entering the parenthesized_label_expression production. + EnterParenthesized_label_expression(c *Parenthesized_label_expressionContext) + + // EnterOpt_graph_element_identifier is called when entering the opt_graph_element_identifier production. + EnterOpt_graph_element_identifier(c *Opt_graph_element_identifierContext) + + // EnterOpt_graph_path_mode_prefix is called when entering the opt_graph_path_mode_prefix production. + EnterOpt_graph_path_mode_prefix(c *Opt_graph_path_mode_prefixContext) + + // EnterPath_or_paths is called when entering the path_or_paths production. + EnterPath_or_paths(c *Path_or_pathsContext) + + // EnterOpt_graph_path_mode is called when entering the opt_graph_path_mode production. + EnterOpt_graph_path_mode(c *Opt_graph_path_modeContext) + + // EnterOpt_graph_search_prefix is called when entering the opt_graph_search_prefix production. + EnterOpt_graph_search_prefix(c *Opt_graph_search_prefixContext) + + // EnterOpt_path_variable_assignment is called when entering the opt_path_variable_assignment production. + EnterOpt_path_variable_assignment(c *Opt_path_variable_assignmentContext) + + // EnterGraph_identifier is called when entering the graph_identifier production. + EnterGraph_identifier(c *Graph_identifierContext) + + // EnterGraph_return_operator is called when entering the graph_return_operator production. + EnterGraph_return_operator(c *Graph_return_operatorContext) + + // EnterGraph_page_clause is called when entering the graph_page_clause production. + EnterGraph_page_clause(c *Graph_page_clauseContext) + + // EnterGraph_order_by_clause is called when entering the graph_order_by_clause production. + EnterGraph_order_by_clause(c *Graph_order_by_clauseContext) + + // EnterGraph_ordering_expression is called when entering the graph_ordering_expression production. + EnterGraph_ordering_expression(c *Graph_ordering_expressionContext) + + // EnterOpt_graph_asc_or_desc is called when entering the opt_graph_asc_or_desc production. + EnterOpt_graph_asc_or_desc(c *Opt_graph_asc_or_descContext) + + // EnterGraph_return_item_list is called when entering the graph_return_item_list production. + EnterGraph_return_item_list(c *Graph_return_item_listContext) + + // EnterGraph_return_item is called when entering the graph_return_item production. + EnterGraph_return_item(c *Graph_return_itemContext) + + // EnterUndrop_statement is called when entering the undrop_statement production. + EnterUndrop_statement(c *Undrop_statementContext) + + // EnterModule_statement is called when entering the module_statement production. + EnterModule_statement(c *Module_statementContext) + + // EnterImport_statement is called when entering the import_statement production. + EnterImport_statement(c *Import_statementContext) + + // EnterOpt_as_or_into_alias is called when entering the opt_as_or_into_alias production. + EnterOpt_as_or_into_alias(c *Opt_as_or_into_aliasContext) + + // EnterPath_expression_or_string is called when entering the path_expression_or_string production. + EnterPath_expression_or_string(c *Path_expression_or_stringContext) + + // EnterImport_type is called when entering the import_type production. + EnterImport_type(c *Import_typeContext) + + // EnterCall_statement is called when entering the call_statement production. + EnterCall_statement(c *Call_statementContext) + + // EnterDrop_statement is called when entering the drop_statement production. + EnterDrop_statement(c *Drop_statementContext) + + // EnterOpt_drop_mode is called when entering the opt_drop_mode production. + EnterOpt_drop_mode(c *Opt_drop_modeContext) + + // EnterDrop_all_row_access_policies_statement is called when entering the drop_all_row_access_policies_statement production. + EnterDrop_all_row_access_policies_statement(c *Drop_all_row_access_policies_statementContext) + + // EnterShow_statement is called when entering the show_statement production. + EnterShow_statement(c *Show_statementContext) + + // EnterOpt_like_string_literal is called when entering the opt_like_string_literal production. + EnterOpt_like_string_literal(c *Opt_like_string_literalContext) + + // EnterShow_target is called when entering the show_target production. + EnterShow_target(c *Show_targetContext) + + // EnterRename_statement is called when entering the rename_statement production. + EnterRename_statement(c *Rename_statementContext) + + // EnterRevoke_statement is called when entering the revoke_statement production. + EnterRevoke_statement(c *Revoke_statementContext) + + // EnterGrant_statement is called when entering the grant_statement production. + EnterGrant_statement(c *Grant_statementContext) + + // EnterPrivileges is called when entering the privileges production. + EnterPrivileges(c *PrivilegesContext) + + // EnterExport_metadata_statement is called when entering the export_metadata_statement production. + EnterExport_metadata_statement(c *Export_metadata_statementContext) + + // EnterExport_model_statement is called when entering the export_model_statement production. + EnterExport_model_statement(c *Export_model_statementContext) + + // EnterExport_data_statement is called when entering the export_data_statement production. + EnterExport_data_statement(c *Export_data_statementContext) + + // EnterExport_data_no_query is called when entering the export_data_no_query production. + EnterExport_data_no_query(c *Export_data_no_queryContext) + + // EnterExplain_statement is called when entering the explain_statement production. + EnterExplain_statement(c *Explain_statementContext) + + // EnterExecute_immediate is called when entering the execute_immediate production. + EnterExecute_immediate(c *Execute_immediateContext) + + // EnterOpt_execute_into_clause is called when entering the opt_execute_into_clause production. + EnterOpt_execute_into_clause(c *Opt_execute_into_clauseContext) + + // EnterOpt_execute_using_clause is called when entering the opt_execute_using_clause production. + EnterOpt_execute_using_clause(c *Opt_execute_using_clauseContext) + + // EnterExecute_using_argument_list is called when entering the execute_using_argument_list production. + EnterExecute_using_argument_list(c *Execute_using_argument_listContext) + + // EnterExecute_using_argument is called when entering the execute_using_argument production. + EnterExecute_using_argument(c *Execute_using_argumentContext) + + // EnterDescribe_statement is called when entering the describe_statement production. + EnterDescribe_statement(c *Describe_statementContext) + + // EnterDescribe_info is called when entering the describe_info production. + EnterDescribe_info(c *Describe_infoContext) + + // EnterOpt_from_path_expression is called when entering the opt_from_path_expression production. + EnterOpt_from_path_expression(c *Opt_from_path_expressionContext) + + // EnterDescribe_keyword is called when entering the describe_keyword production. + EnterDescribe_keyword(c *Describe_keywordContext) + + // EnterDefine_table_statement is called when entering the define_table_statement production. + EnterDefine_table_statement(c *Define_table_statementContext) + + // EnterCreate_entity_statement is called when entering the create_entity_statement production. + EnterCreate_entity_statement(c *Create_entity_statementContext) + + // EnterOpt_generic_entity_body is called when entering the opt_generic_entity_body production. + EnterOpt_generic_entity_body(c *Opt_generic_entity_bodyContext) + + // EnterCreate_view_statement is called when entering the create_view_statement production. + EnterCreate_view_statement(c *Create_view_statementContext) + + // EnterQuery_or_replica_source is called when entering the query_or_replica_source production. + EnterQuery_or_replica_source(c *Query_or_replica_sourceContext) + + // EnterColumn_with_options_list is called when entering the column_with_options_list production. + EnterColumn_with_options_list(c *Column_with_options_listContext) + + // EnterColumn_with_options is called when entering the column_with_options production. + EnterColumn_with_options(c *Column_with_optionsContext) + + // EnterCreate_table_statement is called when entering the create_table_statement production. + EnterCreate_table_statement(c *Create_table_statementContext) + + // EnterOpt_ttl_clause is called when entering the opt_ttl_clause production. + EnterOpt_ttl_clause(c *Opt_ttl_clauseContext) + + // EnterOpt_copy_table is called when entering the opt_copy_table production. + EnterOpt_copy_table(c *Opt_copy_tableContext) + + // EnterCopy_data_source is called when entering the copy_data_source production. + EnterCopy_data_source(c *Copy_data_sourceContext) + + // EnterOpt_clone_table is called when entering the opt_clone_table production. + EnterOpt_clone_table(c *Opt_clone_tableContext) + + // EnterOpt_spanner_table_options is called when entering the opt_spanner_table_options production. + EnterOpt_spanner_table_options(c *Opt_spanner_table_optionsContext) + + // EnterOpt_spanner_interleave_in_parent_clause is called when entering the opt_spanner_interleave_in_parent_clause production. + EnterOpt_spanner_interleave_in_parent_clause(c *Opt_spanner_interleave_in_parent_clauseContext) + + // EnterSpanner_primary_key is called when entering the spanner_primary_key production. + EnterSpanner_primary_key(c *Spanner_primary_keyContext) + + // EnterCreate_table_function_statement is called when entering the create_table_function_statement production. + EnterCreate_table_function_statement(c *Create_table_function_statementContext) + + // EnterOpt_as_query_or_string is called when entering the opt_as_query_or_string production. + EnterOpt_as_query_or_string(c *Opt_as_query_or_stringContext) + + // EnterUnordered_language_options is called when entering the unordered_language_options production. + EnterUnordered_language_options(c *Unordered_language_optionsContext) + + // EnterOpt_function_parameters is called when entering the opt_function_parameters production. + EnterOpt_function_parameters(c *Opt_function_parametersContext) + + // EnterCreate_snapshot_statement is called when entering the create_snapshot_statement production. + EnterCreate_snapshot_statement(c *Create_snapshot_statementContext) + + // EnterCreate_external_schema_statement is called when entering the create_external_schema_statement production. + EnterCreate_external_schema_statement(c *Create_external_schema_statementContext) + + // EnterCreate_schema_statement is called when entering the create_schema_statement production. + EnterCreate_schema_statement(c *Create_schema_statementContext) + + // EnterCreate_property_graph_statement is called when entering the create_property_graph_statement production. + EnterCreate_property_graph_statement(c *Create_property_graph_statementContext) + + // EnterOpt_edge_table_clause is called when entering the opt_edge_table_clause production. + EnterOpt_edge_table_clause(c *Opt_edge_table_clauseContext) + + // EnterElement_table_list is called when entering the element_table_list production. + EnterElement_table_list(c *Element_table_listContext) + + // EnterElement_table_definition is called when entering the element_table_definition production. + EnterElement_table_definition(c *Element_table_definitionContext) + + // EnterOpt_label_and_properties_clause is called when entering the opt_label_and_properties_clause production. + EnterOpt_label_and_properties_clause(c *Opt_label_and_properties_clauseContext) + + // EnterLabel_and_properties_list is called when entering the label_and_properties_list production. + EnterLabel_and_properties_list(c *Label_and_properties_listContext) + + // EnterLabel_and_properties is called when entering the label_and_properties production. + EnterLabel_and_properties(c *Label_and_propertiesContext) + + // EnterProperties_clause is called when entering the properties_clause production. + EnterProperties_clause(c *Properties_clauseContext) + + // EnterDerived_property_list is called when entering the derived_property_list production. + EnterDerived_property_list(c *Derived_property_listContext) + + // EnterDerived_property is called when entering the derived_property production. + EnterDerived_property(c *Derived_propertyContext) + + // EnterOpt_except_column_list is called when entering the opt_except_column_list production. + EnterOpt_except_column_list(c *Opt_except_column_listContext) + + // EnterProperties_all_columns is called when entering the properties_all_columns production. + EnterProperties_all_columns(c *Properties_all_columnsContext) + + // EnterOpt_dest_node_table_clause is called when entering the opt_dest_node_table_clause production. + EnterOpt_dest_node_table_clause(c *Opt_dest_node_table_clauseContext) + + // EnterOpt_source_node_table_clause is called when entering the opt_source_node_table_clause production. + EnterOpt_source_node_table_clause(c *Opt_source_node_table_clauseContext) + + // EnterOpt_key_clause is called when entering the opt_key_clause production. + EnterOpt_key_clause(c *Opt_key_clauseContext) + + // EnterCreate_model_statement is called when entering the create_model_statement production. + EnterCreate_model_statement(c *Create_model_statementContext) + + // EnterOpt_input_output_clause is called when entering the opt_input_output_clause production. + EnterOpt_input_output_clause(c *Opt_input_output_clauseContext) + + // EnterOpt_transform_clause is called when entering the opt_transform_clause production. + EnterOpt_transform_clause(c *Opt_transform_clauseContext) + + // EnterOpt_as_query_or_aliased_query_list is called when entering the opt_as_query_or_aliased_query_list production. + EnterOpt_as_query_or_aliased_query_list(c *Opt_as_query_or_aliased_query_listContext) + + // EnterAliased_query_list is called when entering the aliased_query_list production. + EnterAliased_query_list(c *Aliased_query_listContext) + + // EnterAs_query is called when entering the as_query production. + EnterAs_query(c *As_queryContext) + + // EnterCreate_external_table_function_statement is called when entering the create_external_table_function_statement production. + EnterCreate_external_table_function_statement(c *Create_external_table_function_statementContext) + + // EnterCreate_external_table_statement is called when entering the create_external_table_statement production. + EnterCreate_external_table_statement(c *Create_external_table_statementContext) + + // EnterOpt_default_collate_clause is called when entering the opt_default_collate_clause production. + EnterOpt_default_collate_clause(c *Opt_default_collate_clauseContext) + + // EnterOpt_like_path_expression is called when entering the opt_like_path_expression production. + EnterOpt_like_path_expression(c *Opt_like_path_expressionContext) + + // EnterCreate_row_access_policy_statement is called when entering the create_row_access_policy_statement production. + EnterCreate_row_access_policy_statement(c *Create_row_access_policy_statementContext) + + // EnterFilter_using_clause is called when entering the filter_using_clause production. + EnterFilter_using_clause(c *Filter_using_clauseContext) + + // EnterCreate_row_access_policy_grant_to_clause is called when entering the create_row_access_policy_grant_to_clause production. + EnterCreate_row_access_policy_grant_to_clause(c *Create_row_access_policy_grant_to_clauseContext) + + // EnterCreate_privilege_restriction_statement is called when entering the create_privilege_restriction_statement production. + EnterCreate_privilege_restriction_statement(c *Create_privilege_restriction_statementContext) + + // EnterRestrict_to_clause is called when entering the restrict_to_clause production. + EnterRestrict_to_clause(c *Restrict_to_clauseContext) + + // EnterPossibly_empty_grantee_list is called when entering the possibly_empty_grantee_list production. + EnterPossibly_empty_grantee_list(c *Possibly_empty_grantee_listContext) + + // EnterCreate_index_statement is called when entering the create_index_statement production. + EnterCreate_index_statement(c *Create_index_statementContext) + + // EnterOpt_create_index_statement_suffix is called when entering the opt_create_index_statement_suffix production. + EnterOpt_create_index_statement_suffix(c *Opt_create_index_statement_suffixContext) + + // EnterSpanner_index_interleave_clause is called when entering the spanner_index_interleave_clause production. + EnterSpanner_index_interleave_clause(c *Spanner_index_interleave_clauseContext) + + // EnterIndex_storing_list is called when entering the index_storing_list production. + EnterIndex_storing_list(c *Index_storing_listContext) + + // EnterIndex_storing_expression_list is called when entering the index_storing_expression_list production. + EnterIndex_storing_expression_list(c *Index_storing_expression_listContext) + + // EnterIndex_order_by_and_options is called when entering the index_order_by_and_options production. + EnterIndex_order_by_and_options(c *Index_order_by_and_optionsContext) + + // EnterIndex_all_columns is called when entering the index_all_columns production. + EnterIndex_all_columns(c *Index_all_columnsContext) + + // EnterOpt_with_column_options is called when entering the opt_with_column_options production. + EnterOpt_with_column_options(c *Opt_with_column_optionsContext) + + // EnterAll_column_column_options is called when entering the all_column_column_options production. + EnterAll_column_column_options(c *All_column_column_optionsContext) + + // EnterColumn_ordering_and_options_expr is called when entering the column_ordering_and_options_expr production. + EnterColumn_ordering_and_options_expr(c *Column_ordering_and_options_exprContext) + + // EnterIndex_unnest_expression_list is called when entering the index_unnest_expression_list production. + EnterIndex_unnest_expression_list(c *Index_unnest_expression_listContext) + + // EnterUnnest_expression_with_opt_alias_and_offset is called when entering the unnest_expression_with_opt_alias_and_offset production. + EnterUnnest_expression_with_opt_alias_and_offset(c *Unnest_expression_with_opt_alias_and_offsetContext) + + // EnterOn_path_expression is called when entering the on_path_expression production. + EnterOn_path_expression(c *On_path_expressionContext) + + // EnterIndex_type is called when entering the index_type production. + EnterIndex_type(c *Index_typeContext) + + // EnterOpt_spanner_null_filtered is called when entering the opt_spanner_null_filtered production. + EnterOpt_spanner_null_filtered(c *Opt_spanner_null_filteredContext) + + // EnterCreate_procedure_statement is called when entering the create_procedure_statement production. + EnterCreate_procedure_statement(c *Create_procedure_statementContext) + + // EnterBegin_end_block_or_language_as_code is called when entering the begin_end_block_or_language_as_code production. + EnterBegin_end_block_or_language_as_code(c *Begin_end_block_or_language_as_codeContext) + + // EnterBegin_end_block is called when entering the begin_end_block production. + EnterBegin_end_block(c *Begin_end_blockContext) + + // EnterOpt_exception_handler is called when entering the opt_exception_handler production. + EnterOpt_exception_handler(c *Opt_exception_handlerContext) + + // EnterStatement_list is called when entering the statement_list production. + EnterStatement_list(c *Statement_listContext) + + // EnterUnterminated_non_empty_statement_list is called when entering the unterminated_non_empty_statement_list production. + EnterUnterminated_non_empty_statement_list(c *Unterminated_non_empty_statement_listContext) + + // EnterUnterminated_statement is called when entering the unterminated_statement production. + EnterUnterminated_statement(c *Unterminated_statementContext) + + // EnterUnterminated_script_statement is called when entering the unterminated_script_statement production. + EnterUnterminated_script_statement(c *Unterminated_script_statementContext) + + // EnterLabel is called when entering the label production. + EnterLabel(c *LabelContext) + + // EnterUnterminated_unlabeled_script_statement is called when entering the unterminated_unlabeled_script_statement production. + EnterUnterminated_unlabeled_script_statement(c *Unterminated_unlabeled_script_statementContext) + + // EnterFor_in_statement is called when entering the for_in_statement production. + EnterFor_in_statement(c *For_in_statementContext) + + // EnterRepeat_statement is called when entering the repeat_statement production. + EnterRepeat_statement(c *Repeat_statementContext) + + // EnterUntil_clause is called when entering the until_clause production. + EnterUntil_clause(c *Until_clauseContext) + + // EnterLoop_statement is called when entering the loop_statement production. + EnterLoop_statement(c *Loop_statementContext) + + // EnterWhile_statement is called when entering the while_statement production. + EnterWhile_statement(c *While_statementContext) + + // EnterRaise_statement is called when entering the raise_statement production. + EnterRaise_statement(c *Raise_statementContext) + + // EnterReturn_statement is called when entering the return_statement production. + EnterReturn_statement(c *Return_statementContext) + + // EnterContinue_statement is called when entering the continue_statement production. + EnterContinue_statement(c *Continue_statementContext) + + // EnterVariable_declaration is called when entering the variable_declaration production. + EnterVariable_declaration(c *Variable_declarationContext) + + // EnterBreak_statement is called when entering the break_statement production. + EnterBreak_statement(c *Break_statementContext) + + // EnterCase_statement is called when entering the case_statement production. + EnterCase_statement(c *Case_statementContext) + + // EnterWhen_then_clauses is called when entering the when_then_clauses production. + EnterWhen_then_clauses(c *When_then_clausesContext) + + // EnterIf_statement is called when entering the if_statement production. + EnterIf_statement(c *If_statementContext) + + // EnterElseif_clauses is called when entering the elseif_clauses production. + EnterElseif_clauses(c *Elseif_clausesContext) + + // EnterOpt_else is called when entering the opt_else production. + EnterOpt_else(c *Opt_elseContext) + + // EnterOpt_as_code is called when entering the opt_as_code production. + EnterOpt_as_code(c *Opt_as_codeContext) + + // EnterOpt_external_security_clause is called when entering the opt_external_security_clause production. + EnterOpt_external_security_clause(c *Opt_external_security_clauseContext) + + // EnterExternal_security_clause_kind is called when entering the external_security_clause_kind production. + EnterExternal_security_clause_kind(c *External_security_clause_kindContext) + + // EnterProcedure_parameters is called when entering the procedure_parameters production. + EnterProcedure_parameters(c *Procedure_parametersContext) + + // EnterProcedure_parameter is called when entering the procedure_parameter production. + EnterProcedure_parameter(c *Procedure_parameterContext) + + // EnterProcedure_parameter_termination is called when entering the procedure_parameter_termination production. + EnterProcedure_parameter_termination(c *Procedure_parameter_terminationContext) + + // EnterOpt_procedure_parameter_mode is called when entering the opt_procedure_parameter_mode production. + EnterOpt_procedure_parameter_mode(c *Opt_procedure_parameter_modeContext) + + // EnterCreate_function_statement is called when entering the create_function_statement production. + EnterCreate_function_statement(c *Create_function_statementContext) + + // EnterOpt_determinism_level is called when entering the opt_determinism_level production. + EnterOpt_determinism_level(c *Opt_determinism_levelContext) + + // EnterOpt_sql_security_clause is called when entering the opt_sql_security_clause production. + EnterOpt_sql_security_clause(c *Opt_sql_security_clauseContext) + + // EnterSql_security_clause_kind is called when entering the sql_security_clause_kind production. + EnterSql_security_clause_kind(c *Sql_security_clause_kindContext) + + // EnterAs_sql_function_body_or_string is called when entering the as_sql_function_body_or_string production. + EnterAs_sql_function_body_or_string(c *As_sql_function_body_or_stringContext) + + // EnterSql_function_body is called when entering the sql_function_body production. + EnterSql_function_body(c *Sql_function_bodyContext) + + // EnterUnordered_options_body is called when entering the unordered_options_body production. + EnterUnordered_options_body(c *Unordered_options_bodyContext) + + // EnterOpt_language_or_remote_with_connection is called when entering the opt_language_or_remote_with_connection production. + EnterOpt_language_or_remote_with_connection(c *Opt_language_or_remote_with_connectionContext) + + // EnterLanguage is called when entering the language production. + EnterLanguage(c *LanguageContext) + + // EnterRemote_with_connection_clause is called when entering the remote_with_connection_clause production. + EnterRemote_with_connection_clause(c *Remote_with_connection_clauseContext) + + // EnterWith_connection_clause is called when entering the with_connection_clause production. + EnterWith_connection_clause(c *With_connection_clauseContext) + + // EnterOpt_function_returns is called when entering the opt_function_returns production. + EnterOpt_function_returns(c *Opt_function_returnsContext) + + // EnterOpt_returns is called when entering the opt_returns production. + EnterOpt_returns(c *Opt_returnsContext) + + // EnterFunction_declaration is called when entering the function_declaration production. + EnterFunction_declaration(c *Function_declarationContext) + + // EnterFunction_parameters is called when entering the function_parameters production. + EnterFunction_parameters(c *Function_parametersContext) + + // EnterFunction_parameter is called when entering the function_parameter production. + EnterFunction_parameter(c *Function_parameterContext) + + // EnterOpt_not_aggregate is called when entering the opt_not_aggregate production. + EnterOpt_not_aggregate(c *Opt_not_aggregateContext) + + // EnterOpt_default_expression is called when entering the opt_default_expression production. + EnterOpt_default_expression(c *Opt_default_expressionContext) + + // EnterType_or_tvf_schema is called when entering the type_or_tvf_schema production. + EnterType_or_tvf_schema(c *Type_or_tvf_schemaContext) + + // EnterTvf_schema is called when entering the tvf_schema production. + EnterTvf_schema(c *Tvf_schemaContext) + + // EnterTvf_schema_column is called when entering the tvf_schema_column production. + EnterTvf_schema_column(c *Tvf_schema_columnContext) + + // EnterTemplated_parameter_type is called when entering the templated_parameter_type production. + EnterTemplated_parameter_type(c *Templated_parameter_typeContext) + + // EnterTemplated_parameter_kind is called when entering the templated_parameter_kind production. + EnterTemplated_parameter_kind(c *Templated_parameter_kindContext) + + // EnterOpt_aggregate is called when entering the opt_aggregate production. + EnterOpt_aggregate(c *Opt_aggregateContext) + + // EnterCreate_database_statement is called when entering the create_database_statement production. + EnterCreate_database_statement(c *Create_database_statementContext) + + // EnterCreate_connection_statement is called when entering the create_connection_statement production. + EnterCreate_connection_statement(c *Create_connection_statementContext) + + // EnterCreate_constant_statement is called when entering the create_constant_statement production. + EnterCreate_constant_statement(c *Create_constant_statementContext) + + // EnterOpt_or_replace is called when entering the opt_or_replace production. + EnterOpt_or_replace(c *Opt_or_replaceContext) + + // EnterOpt_create_scope is called when entering the opt_create_scope production. + EnterOpt_create_scope(c *Opt_create_scopeContext) + + // EnterRun_batch_statement is called when entering the run_batch_statement production. + EnterRun_batch_statement(c *Run_batch_statementContext) + + // EnterAbort_batch_statement is called when entering the abort_batch_statement production. + EnterAbort_batch_statement(c *Abort_batch_statementContext) + + // EnterStart_batch_statement is called when entering the start_batch_statement production. + EnterStart_batch_statement(c *Start_batch_statementContext) + + // EnterRollback_statement is called when entering the rollback_statement production. + EnterRollback_statement(c *Rollback_statementContext) + + // EnterCommit_statement is called when entering the commit_statement production. + EnterCommit_statement(c *Commit_statementContext) + + // EnterSet_statement is called when entering the set_statement production. + EnterSet_statement(c *Set_statementContext) + + // EnterIdentifier_list is called when entering the identifier_list production. + EnterIdentifier_list(c *Identifier_listContext) + + // EnterBegin_statement is called when entering the begin_statement production. + EnterBegin_statement(c *Begin_statementContext) + + // EnterBegin_transaction_keywords is called when entering the begin_transaction_keywords production. + EnterBegin_transaction_keywords(c *Begin_transaction_keywordsContext) + + // EnterTransaction_mode_list is called when entering the transaction_mode_list production. + EnterTransaction_mode_list(c *Transaction_mode_listContext) + + // EnterTransaction_mode is called when entering the transaction_mode production. + EnterTransaction_mode(c *Transaction_modeContext) + + // EnterTruncate_statement is called when entering the truncate_statement production. + EnterTruncate_statement(c *Truncate_statementContext) + + // EnterMerge_statement is called when entering the merge_statement production. + EnterMerge_statement(c *Merge_statementContext) + + // EnterMerge_source is called when entering the merge_source production. + EnterMerge_source(c *Merge_sourceContext) + + // EnterMerge_when_clause is called when entering the merge_when_clause production. + EnterMerge_when_clause(c *Merge_when_clauseContext) + + // EnterMerge_action is called when entering the merge_action production. + EnterMerge_action(c *Merge_actionContext) + + // EnterMerge_insert_value_list_or_source_row is called when entering the merge_insert_value_list_or_source_row production. + EnterMerge_insert_value_list_or_source_row(c *Merge_insert_value_list_or_source_rowContext) + + // EnterBy_target is called when entering the by_target production. + EnterBy_target(c *By_targetContext) + + // EnterOpt_and_expression is called when entering the opt_and_expression production. + EnterOpt_and_expression(c *Opt_and_expressionContext) + + // EnterStatement_level_hint is called when entering the statement_level_hint production. + EnterStatement_level_hint(c *Statement_level_hintContext) + + // EnterQuery_statement is called when entering the query_statement production. + EnterQuery_statement(c *Query_statementContext) + + // EnterDml_statement is called when entering the dml_statement production. + EnterDml_statement(c *Dml_statementContext) + + // EnterUpdate_statement is called when entering the update_statement production. + EnterUpdate_statement(c *Update_statementContext) + + // EnterDelete_statement is called when entering the delete_statement production. + EnterDelete_statement(c *Delete_statementContext) + + // EnterInsert_statement is called when entering the insert_statement production. + EnterInsert_statement(c *Insert_statementContext) + + // EnterOn_conflict_clause is called when entering the on_conflict_clause production. + EnterOn_conflict_clause(c *On_conflict_clauseContext) + + // EnterOpt_where_expression is called when entering the opt_where_expression production. + EnterOpt_where_expression(c *Opt_where_expressionContext) + + // EnterOpt_conflict_target is called when entering the opt_conflict_target production. + EnterOpt_conflict_target(c *Opt_conflict_targetContext) + + // EnterUpdate_item_list is called when entering the update_item_list production. + EnterUpdate_item_list(c *Update_item_listContext) + + // EnterUpdate_item is called when entering the update_item production. + EnterUpdate_item(c *Update_itemContext) + + // EnterUpdate_set_value is called when entering the update_set_value production. + EnterUpdate_set_value(c *Update_set_valueContext) + + // EnterNested_dml_statement is called when entering the nested_dml_statement production. + EnterNested_dml_statement(c *Nested_dml_statementContext) + + // EnterInsert_values_list_or_table_clause is called when entering the insert_values_list_or_table_clause production. + EnterInsert_values_list_or_table_clause(c *Insert_values_list_or_table_clauseContext) + + // EnterTable_clause_unreversed is called when entering the table_clause_unreversed production. + EnterTable_clause_unreversed(c *Table_clause_unreversedContext) + + // EnterTable_clause_no_keyword is called when entering the table_clause_no_keyword production. + EnterTable_clause_no_keyword(c *Table_clause_no_keywordContext) + + // EnterOpt_returning_clause is called when entering the opt_returning_clause production. + EnterOpt_returning_clause(c *Opt_returning_clauseContext) + + // EnterOpt_assert_rows_modified is called when entering the opt_assert_rows_modified production. + EnterOpt_assert_rows_modified(c *Opt_assert_rows_modifiedContext) + + // EnterInsert_values_or_query is called when entering the insert_values_or_query production. + EnterInsert_values_or_query(c *Insert_values_or_queryContext) + + // EnterInsert_values_list is called when entering the insert_values_list production. + EnterInsert_values_list(c *Insert_values_listContext) + + // EnterInsert_values_row is called when entering the insert_values_row production. + EnterInsert_values_row(c *Insert_values_rowContext) + + // EnterExpression_or_default is called when entering the expression_or_default production. + EnterExpression_or_default(c *Expression_or_defaultContext) + + // EnterInsert_statement_prefix is called when entering the insert_statement_prefix production. + EnterInsert_statement_prefix(c *Insert_statement_prefixContext) + + // EnterMaybe_dashed_generalized_path_expression is called when entering the maybe_dashed_generalized_path_expression production. + EnterMaybe_dashed_generalized_path_expression(c *Maybe_dashed_generalized_path_expressionContext) + + // EnterOpt_into is called when entering the opt_into production. + EnterOpt_into(c *Opt_intoContext) + + // EnterOpt_or_ignore_replace_update is called when entering the opt_or_ignore_replace_update production. + EnterOpt_or_ignore_replace_update(c *Opt_or_ignore_replace_updateContext) + + // EnterAlter_statement is called when entering the alter_statement production. + EnterAlter_statement(c *Alter_statementContext) + + // EnterAnalyze_statement is called when entering the analyze_statement production. + EnterAnalyze_statement(c *Analyze_statementContext) + + // EnterAssert_statement is called when entering the assert_statement production. + EnterAssert_statement(c *Assert_statementContext) + + // EnterAux_load_data_statement is called when entering the aux_load_data_statement production. + EnterAux_load_data_statement(c *Aux_load_data_statementContext) + + // EnterClone_data_statement is called when entering the clone_data_statement production. + EnterClone_data_statement(c *Clone_data_statementContext) + + // EnterClone_data_source_list is called when entering the clone_data_source_list production. + EnterClone_data_source_list(c *Clone_data_source_listContext) + + // EnterClone_data_source is called when entering the clone_data_source production. + EnterClone_data_source(c *Clone_data_sourceContext) + + // EnterOpt_external_table_with_clauses is called when entering the opt_external_table_with_clauses production. + EnterOpt_external_table_with_clauses(c *Opt_external_table_with_clausesContext) + + // EnterWith_partition_columns_clause is called when entering the with_partition_columns_clause production. + EnterWith_partition_columns_clause(c *With_partition_columns_clauseContext) + + // EnterAux_load_data_from_files_options_list is called when entering the aux_load_data_from_files_options_list production. + EnterAux_load_data_from_files_options_list(c *Aux_load_data_from_files_options_listContext) + + // EnterCluster_by_clause_prefix_no_hint is called when entering the cluster_by_clause_prefix_no_hint production. + EnterCluster_by_clause_prefix_no_hint(c *Cluster_by_clause_prefix_no_hintContext) + + // EnterLoad_data_partitions_clause is called when entering the load_data_partitions_clause production. + EnterLoad_data_partitions_clause(c *Load_data_partitions_clauseContext) + + // EnterMaybe_dashed_path_expression_with_scope is called when entering the maybe_dashed_path_expression_with_scope production. + EnterMaybe_dashed_path_expression_with_scope(c *Maybe_dashed_path_expression_with_scopeContext) + + // EnterTable_element_list is called when entering the table_element_list production. + EnterTable_element_list(c *Table_element_listContext) + + // EnterTable_element is called when entering the table_element production. + EnterTable_element(c *Table_elementContext) + + // EnterTable_constraint_definition is called when entering the table_constraint_definition production. + EnterTable_constraint_definition(c *Table_constraint_definitionContext) + + // EnterAppend_or_overwrite is called when entering the append_or_overwrite production. + EnterAppend_or_overwrite(c *Append_or_overwriteContext) + + // EnterOpt_description is called when entering the opt_description production. + EnterOpt_description(c *Opt_descriptionContext) + + // EnterTable_and_column_info_list is called when entering the table_and_column_info_list production. + EnterTable_and_column_info_list(c *Table_and_column_info_listContext) + + // EnterTable_and_column_info is called when entering the table_and_column_info production. + EnterTable_and_column_info(c *Table_and_column_infoContext) + + // EnterRow_access_policy_alter_action_list is called when entering the row_access_policy_alter_action_list production. + EnterRow_access_policy_alter_action_list(c *Row_access_policy_alter_action_listContext) + + // EnterRow_access_policy_alter_action is called when entering the row_access_policy_alter_action production. + EnterRow_access_policy_alter_action(c *Row_access_policy_alter_actionContext) + + // EnterGrant_to_clause is called when entering the grant_to_clause production. + EnterGrant_to_clause(c *Grant_to_clauseContext) + + // EnterGrantee_list is called when entering the grantee_list production. + EnterGrantee_list(c *Grantee_listContext) + + // EnterPrivilege_list is called when entering the privilege_list production. + EnterPrivilege_list(c *Privilege_listContext) + + // EnterPrivilege is called when entering the privilege production. + EnterPrivilege(c *PrivilegeContext) + + // EnterPath_expression_list_with_parens is called when entering the path_expression_list_with_parens production. + EnterPath_expression_list_with_parens(c *Path_expression_list_with_parensContext) + + // EnterPrivilege_name is called when entering the privilege_name production. + EnterPrivilege_name(c *Privilege_nameContext) + + // EnterGeneric_entity_type is called when entering the generic_entity_type production. + EnterGeneric_entity_type(c *Generic_entity_typeContext) + + // EnterGeneric_entity_type_unchecked is called when entering the generic_entity_type_unchecked production. + EnterGeneric_entity_type_unchecked(c *Generic_entity_type_uncheckedContext) + + // EnterSchema_object_kind is called when entering the schema_object_kind production. + EnterSchema_object_kind(c *Schema_object_kindContext) + + // EnterAlter_action_list is called when entering the alter_action_list production. + EnterAlter_action_list(c *Alter_action_listContext) + + // EnterAlter_action is called when entering the alter_action production. + EnterAlter_action(c *Alter_actionContext) + + // EnterSpanner_set_on_delete_action is called when entering the spanner_set_on_delete_action production. + EnterSpanner_set_on_delete_action(c *Spanner_set_on_delete_actionContext) + + // EnterSpanner_alter_column_action is called when entering the spanner_alter_column_action production. + EnterSpanner_alter_column_action(c *Spanner_alter_column_actionContext) + + // EnterSpanner_generated_or_default is called when entering the spanner_generated_or_default production. + EnterSpanner_generated_or_default(c *Spanner_generated_or_defaultContext) + + // EnterGeneric_sub_entity_type is called when entering the generic_sub_entity_type production. + EnterGeneric_sub_entity_type(c *Generic_sub_entity_typeContext) + + // EnterSub_entity_type_identifier is called when entering the sub_entity_type_identifier production. + EnterSub_entity_type_identifier(c *Sub_entity_type_identifierContext) + + // EnterFill_using_expression is called when entering the fill_using_expression production. + EnterFill_using_expression(c *Fill_using_expressionContext) + + // EnterColumn_position is called when entering the column_position production. + EnterColumn_position(c *Column_positionContext) + + // EnterTable_column_definition is called when entering the table_column_definition production. + EnterTable_column_definition(c *Table_column_definitionContext) + + // EnterColumn_attributes is called when entering the column_attributes production. + EnterColumn_attributes(c *Column_attributesContext) + + // EnterColumn_attribute is called when entering the column_attribute production. + EnterColumn_attribute(c *Column_attributeContext) + + // EnterPrimary_key_column_attribute is called when entering the primary_key_column_attribute production. + EnterPrimary_key_column_attribute(c *Primary_key_column_attributeContext) + + // EnterForeign_key_column_attribute is called when entering the foreign_key_column_attribute production. + EnterForeign_key_column_attribute(c *Foreign_key_column_attributeContext) + + // EnterHidden_column_attribute is called when entering the hidden_column_attribute production. + EnterHidden_column_attribute(c *Hidden_column_attributeContext) + + // EnterOpt_constraint_identity is called when entering the opt_constraint_identity production. + EnterOpt_constraint_identity(c *Opt_constraint_identityContext) + + // EnterTable_column_schema is called when entering the table_column_schema production. + EnterTable_column_schema(c *Table_column_schemaContext) + + // EnterOpt_column_info is called when entering the opt_column_info production. + EnterOpt_column_info(c *Opt_column_infoContext) + + // EnterInvalid_generated_column is called when entering the invalid_generated_column production. + EnterInvalid_generated_column(c *Invalid_generated_columnContext) + + // EnterInvalid_default_column is called when entering the invalid_default_column production. + EnterInvalid_default_column(c *Invalid_default_columnContext) + + // EnterDefault_column_info is called when entering the default_column_info production. + EnterDefault_column_info(c *Default_column_infoContext) + + // EnterGenerated_column_info is called when entering the generated_column_info production. + EnterGenerated_column_info(c *Generated_column_infoContext) + + // EnterIdentity_column_info is called when entering the identity_column_info production. + EnterIdentity_column_info(c *Identity_column_infoContext) + + // EnterOpt_start_with is called when entering the opt_start_with production. + EnterOpt_start_with(c *Opt_start_withContext) + + // EnterOpt_increment_by is called when entering the opt_increment_by production. + EnterOpt_increment_by(c *Opt_increment_byContext) + + // EnterOpt_maxvalue is called when entering the opt_maxvalue production. + EnterOpt_maxvalue(c *Opt_maxvalueContext) + + // EnterOpt_minvalue is called when entering the opt_minvalue production. + EnterOpt_minvalue(c *Opt_minvalueContext) + + // EnterOpt_cycle is called when entering the opt_cycle production. + EnterOpt_cycle(c *Opt_cycleContext) + + // EnterSigned_numeric_literal is called when entering the signed_numeric_literal production. + EnterSigned_numeric_literal(c *Signed_numeric_literalContext) + + // EnterStored_mode is called when entering the stored_mode production. + EnterStored_mode(c *Stored_modeContext) + + // EnterGenerated_mode is called when entering the generated_mode production. + EnterGenerated_mode(c *Generated_modeContext) + + // EnterColumn_schema_inner is called when entering the column_schema_inner production. + EnterColumn_schema_inner(c *Column_schema_innerContext) + + // EnterRaw_column_schema_inner is called when entering the raw_column_schema_inner production. + EnterRaw_column_schema_inner(c *Raw_column_schema_innerContext) + + // EnterRange_column_schema_inner is called when entering the range_column_schema_inner production. + EnterRange_column_schema_inner(c *Range_column_schema_innerContext) + + // EnterStruct_column_schema_inner is called when entering the struct_column_schema_inner production. + EnterStruct_column_schema_inner(c *Struct_column_schema_innerContext) + + // EnterStruct_column_field is called when entering the struct_column_field production. + EnterStruct_column_field(c *Struct_column_fieldContext) + + // EnterSimple_column_schema_inner is called when entering the simple_column_schema_inner production. + EnterSimple_column_schema_inner(c *Simple_column_schema_innerContext) + + // EnterArray_column_schema_inner is called when entering the array_column_schema_inner production. + EnterArray_column_schema_inner(c *Array_column_schema_innerContext) + + // EnterField_schema is called when entering the field_schema production. + EnterField_schema(c *Field_schemaContext) + + // EnterOpt_field_attributes is called when entering the opt_field_attributes production. + EnterOpt_field_attributes(c *Opt_field_attributesContext) + + // EnterNot_null_column_attribute is called when entering the not_null_column_attribute production. + EnterNot_null_column_attribute(c *Not_null_column_attributeContext) + + // EnterPrimary_key_or_table_constraint_spec is called when entering the primary_key_or_table_constraint_spec production. + EnterPrimary_key_or_table_constraint_spec(c *Primary_key_or_table_constraint_specContext) + + // EnterOpt_if_not_exists is called when entering the opt_if_not_exists production. + EnterOpt_if_not_exists(c *Opt_if_not_existsContext) + + // EnterPrimary_key_spec is called when entering the primary_key_spec production. + EnterPrimary_key_spec(c *Primary_key_specContext) + + // EnterPrimary_key_element_list is called when entering the primary_key_element_list production. + EnterPrimary_key_element_list(c *Primary_key_element_listContext) + + // EnterPrimary_key_element is called when entering the primary_key_element production. + EnterPrimary_key_element(c *Primary_key_elementContext) + + // EnterTable_constraint_spec is called when entering the table_constraint_spec production. + EnterTable_constraint_spec(c *Table_constraint_specContext) + + // EnterForeign_key_reference is called when entering the foreign_key_reference production. + EnterForeign_key_reference(c *Foreign_key_referenceContext) + + // EnterOpt_foreign_key_action is called when entering the opt_foreign_key_action production. + EnterOpt_foreign_key_action(c *Opt_foreign_key_actionContext) + + // EnterForeign_key_on_update is called when entering the foreign_key_on_update production. + EnterForeign_key_on_update(c *Foreign_key_on_updateContext) + + // EnterForeign_key_on_delete is called when entering the foreign_key_on_delete production. + EnterForeign_key_on_delete(c *Foreign_key_on_deleteContext) + + // EnterForeign_key_action is called when entering the foreign_key_action production. + EnterForeign_key_action(c *Foreign_key_actionContext) + + // EnterOpt_foreign_key_match is called when entering the opt_foreign_key_match production. + EnterOpt_foreign_key_match(c *Opt_foreign_key_matchContext) + + // EnterForeign_key_match_mode is called when entering the foreign_key_match_mode production. + EnterForeign_key_match_mode(c *Foreign_key_match_modeContext) + + // EnterColumn_list is called when entering the column_list production. + EnterColumn_list(c *Column_listContext) + + // EnterOpt_options_list is called when entering the opt_options_list production. + EnterOpt_options_list(c *Opt_options_listContext) + + // EnterConstraint_enforcement is called when entering the constraint_enforcement production. + EnterConstraint_enforcement(c *Constraint_enforcementContext) + + // EnterGeneric_entity_body is called when entering the generic_entity_body production. + EnterGeneric_entity_body(c *Generic_entity_bodyContext) + + // EnterOpt_if_exists is called when entering the opt_if_exists production. + EnterOpt_if_exists(c *Opt_if_existsContext) + + // EnterTable_or_table_function is called when entering the table_or_table_function production. + EnterTable_or_table_function(c *Table_or_table_functionContext) + + // EnterQuery is called when entering the query production. + EnterQuery(c *QueryContext) + + // EnterQuery_without_pipe_operators is called when entering the query_without_pipe_operators production. + EnterQuery_without_pipe_operators(c *Query_without_pipe_operatorsContext) + + // EnterBad_keyword_after_from_query is called when entering the bad_keyword_after_from_query production. + EnterBad_keyword_after_from_query(c *Bad_keyword_after_from_queryContext) + + // EnterBad_keyword_after_from_query_allows_parens is called when entering the bad_keyword_after_from_query_allows_parens production. + EnterBad_keyword_after_from_query_allows_parens(c *Bad_keyword_after_from_query_allows_parensContext) + + // EnterWith_clause_with_trailing_comma is called when entering the with_clause_with_trailing_comma production. + EnterWith_clause_with_trailing_comma(c *With_clause_with_trailing_commaContext) + + // EnterSelect_or_from_keyword is called when entering the select_or_from_keyword production. + EnterSelect_or_from_keyword(c *Select_or_from_keywordContext) + + // EnterQuery_primary_or_set_operation is called when entering the query_primary_or_set_operation production. + EnterQuery_primary_or_set_operation(c *Query_primary_or_set_operationContext) + + // EnterQuery_set_operation is called when entering the query_set_operation production. + EnterQuery_set_operation(c *Query_set_operationContext) + + // EnterQuery_set_operation_prefix is called when entering the query_set_operation_prefix production. + EnterQuery_set_operation_prefix(c *Query_set_operation_prefixContext) + + // EnterQuery_set_operation_item is called when entering the query_set_operation_item production. + EnterQuery_set_operation_item(c *Query_set_operation_itemContext) + + // EnterQuery_primary is called when entering the query_primary production. + EnterQuery_primary(c *Query_primaryContext) + + // EnterSet_operation_metadata is called when entering the set_operation_metadata production. + EnterSet_operation_metadata(c *Set_operation_metadataContext) + + // EnterOpt_column_match_suffix is called when entering the opt_column_match_suffix production. + EnterOpt_column_match_suffix(c *Opt_column_match_suffixContext) + + // EnterOpt_strict is called when entering the opt_strict production. + EnterOpt_strict(c *Opt_strictContext) + + // EnterAll_or_distinct is called when entering the all_or_distinct production. + EnterAll_or_distinct(c *All_or_distinctContext) + + // EnterQuery_set_operation_type is called when entering the query_set_operation_type production. + EnterQuery_set_operation_type(c *Query_set_operation_typeContext) + + // EnterOpt_corresponding_outer_mode is called when entering the opt_corresponding_outer_mode production. + EnterOpt_corresponding_outer_mode(c *Opt_corresponding_outer_modeContext) + + // EnterOpt_outer is called when entering the opt_outer production. + EnterOpt_outer(c *Opt_outerContext) + + // EnterWith_clause is called when entering the with_clause production. + EnterWith_clause(c *With_clauseContext) + + // EnterAliased_query is called when entering the aliased_query production. + EnterAliased_query(c *Aliased_queryContext) + + // EnterOpt_aliased_query_modifiers is called when entering the opt_aliased_query_modifiers production. + EnterOpt_aliased_query_modifiers(c *Opt_aliased_query_modifiersContext) + + // EnterRecursion_depth_modifier is called when entering the recursion_depth_modifier production. + EnterRecursion_depth_modifier(c *Recursion_depth_modifierContext) + + // EnterPossibly_unbounded_int_literal_or_parameter is called when entering the possibly_unbounded_int_literal_or_parameter production. + EnterPossibly_unbounded_int_literal_or_parameter(c *Possibly_unbounded_int_literal_or_parameterContext) + + // EnterInt_literal_or_parameter is called when entering the int_literal_or_parameter production. + EnterInt_literal_or_parameter(c *Int_literal_or_parameterContext) + + // EnterOrder_by_clause is called when entering the order_by_clause production. + EnterOrder_by_clause(c *Order_by_clauseContext) + + // EnterOrder_by_clause_prefix is called when entering the order_by_clause_prefix production. + EnterOrder_by_clause_prefix(c *Order_by_clause_prefixContext) + + // EnterOrdering_expression is called when entering the ordering_expression production. + EnterOrdering_expression(c *Ordering_expressionContext) + + // EnterSelect is called when entering the select production. + EnterSelect(c *SelectContext) + + // EnterOpt_clauses_following_from is called when entering the opt_clauses_following_from production. + EnterOpt_clauses_following_from(c *Opt_clauses_following_fromContext) + + // EnterOpt_clauses_following_where is called when entering the opt_clauses_following_where production. + EnterOpt_clauses_following_where(c *Opt_clauses_following_whereContext) + + // EnterOpt_clauses_following_group_by is called when entering the opt_clauses_following_group_by production. + EnterOpt_clauses_following_group_by(c *Opt_clauses_following_group_byContext) + + // EnterWindow_clause is called when entering the window_clause production. + EnterWindow_clause(c *Window_clauseContext) + + // EnterWindow_clause_prefix is called when entering the window_clause_prefix production. + EnterWindow_clause_prefix(c *Window_clause_prefixContext) + + // EnterWindow_definition is called when entering the window_definition production. + EnterWindow_definition(c *Window_definitionContext) + + // EnterWhere_clause is called when entering the where_clause production. + EnterWhere_clause(c *Where_clauseContext) + + // EnterHaving_clause is called when entering the having_clause production. + EnterHaving_clause(c *Having_clauseContext) + + // EnterGroup_by_clause is called when entering the group_by_clause production. + EnterGroup_by_clause(c *Group_by_clauseContext) + + // EnterGroup_by_all is called when entering the group_by_all production. + EnterGroup_by_all(c *Group_by_allContext) + + // EnterSelect_clause is called when entering the select_clause production. + EnterSelect_clause(c *Select_clauseContext) + + // EnterOpt_select_as_clause is called when entering the opt_select_as_clause production. + EnterOpt_select_as_clause(c *Opt_select_as_clauseContext) + + // EnterOpt_select_with is called when entering the opt_select_with production. + EnterOpt_select_with(c *Opt_select_withContext) + + // EnterFrom_clause is called when entering the from_clause production. + EnterFrom_clause(c *From_clauseContext) + + // EnterFrom_clause_contents is called when entering the from_clause_contents production. + EnterFrom_clause_contents(c *From_clause_contentsContext) + + // EnterFrom_clause_contents_suffix is called when entering the from_clause_contents_suffix production. + EnterFrom_clause_contents_suffix(c *From_clause_contents_suffixContext) + + // EnterTable_primary is called when entering the table_primary production. + EnterTable_primary(c *Table_primaryContext) + + // EnterTvf_with_suffixes is called when entering the tvf_with_suffixes production. + EnterTvf_with_suffixes(c *Tvf_with_suffixesContext) + + // EnterPivot_or_unpivot_clause_and_aliases is called when entering the pivot_or_unpivot_clause_and_aliases production. + EnterPivot_or_unpivot_clause_and_aliases(c *Pivot_or_unpivot_clause_and_aliasesContext) + + // EnterAs_alias is called when entering the as_alias production. + EnterAs_alias(c *As_aliasContext) + + // EnterSample_clause is called when entering the sample_clause production. + EnterSample_clause(c *Sample_clauseContext) + + // EnterOpt_sample_clause_suffix is called when entering the opt_sample_clause_suffix production. + EnterOpt_sample_clause_suffix(c *Opt_sample_clause_suffixContext) + + // EnterRepeatable_clause is called when entering the repeatable_clause production. + EnterRepeatable_clause(c *Repeatable_clauseContext) + + // EnterPossibly_cast_int_literal_or_parameter is called when entering the possibly_cast_int_literal_or_parameter production. + EnterPossibly_cast_int_literal_or_parameter(c *Possibly_cast_int_literal_or_parameterContext) + + // EnterCast_int_literal_or_parameter is called when entering the cast_int_literal_or_parameter production. + EnterCast_int_literal_or_parameter(c *Cast_int_literal_or_parameterContext) + + // EnterSample_size is called when entering the sample_size production. + EnterSample_size(c *Sample_sizeContext) + + // EnterSample_size_value is called when entering the sample_size_value production. + EnterSample_size_value(c *Sample_size_valueContext) + + // EnterSample_size_unit is called when entering the sample_size_unit production. + EnterSample_size_unit(c *Sample_size_unitContext) + + // EnterPartition_by_clause_prefix_no_hint is called when entering the partition_by_clause_prefix_no_hint production. + EnterPartition_by_clause_prefix_no_hint(c *Partition_by_clause_prefix_no_hintContext) + + // EnterMatch_recognize_clause is called when entering the match_recognize_clause production. + EnterMatch_recognize_clause(c *Match_recognize_clauseContext) + + // EnterRow_pattern_expr is called when entering the row_pattern_expr production. + EnterRow_pattern_expr(c *Row_pattern_exprContext) + + // EnterRow_pattern_concatenation is called when entering the row_pattern_concatenation production. + EnterRow_pattern_concatenation(c *Row_pattern_concatenationContext) + + // EnterRow_pattern_factor is called when entering the row_pattern_factor production. + EnterRow_pattern_factor(c *Row_pattern_factorContext) + + // EnterSelect_list_prefix_with_as_aliases is called when entering the select_list_prefix_with_as_aliases production. + EnterSelect_list_prefix_with_as_aliases(c *Select_list_prefix_with_as_aliasesContext) + + // EnterSelect_column_expr_with_as_alias is called when entering the select_column_expr_with_as_alias production. + EnterSelect_column_expr_with_as_alias(c *Select_column_expr_with_as_aliasContext) + + // EnterTable_subquery is called when entering the table_subquery production. + EnterTable_subquery(c *Table_subqueryContext) + + // EnterJoin is called when entering the join production. + EnterJoin(c *JoinContext) + + // EnterJoin_item is called when entering the join_item production. + EnterJoin_item(c *Join_itemContext) + + // EnterOn_or_using_clause_list is called when entering the on_or_using_clause_list production. + EnterOn_or_using_clause_list(c *On_or_using_clause_listContext) + + // EnterOn_or_using_clause is called when entering the on_or_using_clause production. + EnterOn_or_using_clause(c *On_or_using_clauseContext) + + // EnterUsing_clause is called when entering the using_clause production. + EnterUsing_clause(c *Using_clauseContext) + + // EnterJoin_hint is called when entering the join_hint production. + EnterJoin_hint(c *Join_hintContext) + + // EnterTable_path_expression is called when entering the table_path_expression production. + EnterTable_path_expression(c *Table_path_expressionContext) + + // EnterOpt_at_system_time is called when entering the opt_at_system_time production. + EnterOpt_at_system_time(c *Opt_at_system_timeContext) + + // EnterOpt_with_offset_and_alias is called when entering the opt_with_offset_and_alias production. + EnterOpt_with_offset_and_alias(c *Opt_with_offset_and_aliasContext) + + // EnterOpt_pivot_or_unpivot_clause_and_alias is called when entering the opt_pivot_or_unpivot_clause_and_alias production. + EnterOpt_pivot_or_unpivot_clause_and_alias(c *Opt_pivot_or_unpivot_clause_and_aliasContext) + + // EnterTable_path_expression_base is called when entering the table_path_expression_base production. + EnterTable_path_expression_base(c *Table_path_expression_baseContext) + + // EnterMaybe_slashed_or_dashed_path_expression is called when entering the maybe_slashed_or_dashed_path_expression production. + EnterMaybe_slashed_or_dashed_path_expression(c *Maybe_slashed_or_dashed_path_expressionContext) + + // EnterMaybe_dashed_path_expression is called when entering the maybe_dashed_path_expression production. + EnterMaybe_dashed_path_expression(c *Maybe_dashed_path_expressionContext) + + // EnterDashed_path_expression is called when entering the dashed_path_expression production. + EnterDashed_path_expression(c *Dashed_path_expressionContext) + + // EnterDashed_identifier is called when entering the dashed_identifier production. + EnterDashed_identifier(c *Dashed_identifierContext) + + // EnterSlashed_identifier is called when entering the slashed_identifier production. + EnterSlashed_identifier(c *Slashed_identifierContext) + + // EnterIdentifier_or_integer is called when entering the identifier_or_integer production. + EnterIdentifier_or_integer(c *Identifier_or_integerContext) + + // EnterSlashed_identifier_separator is called when entering the slashed_identifier_separator production. + EnterSlashed_identifier_separator(c *Slashed_identifier_separatorContext) + + // EnterSlashed_path_expression is called when entering the slashed_path_expression production. + EnterSlashed_path_expression(c *Slashed_path_expressionContext) + + // EnterUnnest_expression is called when entering the unnest_expression production. + EnterUnnest_expression(c *Unnest_expressionContext) + + // EnterUnnest_expression_prefix is called when entering the unnest_expression_prefix production. + EnterUnnest_expression_prefix(c *Unnest_expression_prefixContext) + + // EnterOpt_array_zip_mode is called when entering the opt_array_zip_mode production. + EnterOpt_array_zip_mode(c *Opt_array_zip_modeContext) + + // EnterExpression_with_opt_alias is called when entering the expression_with_opt_alias production. + EnterExpression_with_opt_alias(c *Expression_with_opt_aliasContext) + + // EnterTvf_prefix is called when entering the tvf_prefix production. + EnterTvf_prefix(c *Tvf_prefixContext) + + // EnterTvf_argument is called when entering the tvf_argument production. + EnterTvf_argument(c *Tvf_argumentContext) + + // EnterConnection_clause is called when entering the connection_clause production. + EnterConnection_clause(c *Connection_clauseContext) + + // EnterPath_expression_or_default is called when entering the path_expression_or_default production. + EnterPath_expression_or_default(c *Path_expression_or_defaultContext) + + // EnterDescriptor_argument is called when entering the descriptor_argument production. + EnterDescriptor_argument(c *Descriptor_argumentContext) + + // EnterDescriptor_column_list is called when entering the descriptor_column_list production. + EnterDescriptor_column_list(c *Descriptor_column_listContext) + + // EnterDescriptor_column is called when entering the descriptor_column production. + EnterDescriptor_column(c *Descriptor_columnContext) + + // EnterTable_clause is called when entering the table_clause production. + EnterTable_clause(c *Table_clauseContext) + + // EnterModel_clause is called when entering the model_clause production. + EnterModel_clause(c *Model_clauseContext) + + // EnterQualify_clause_nonreserved is called when entering the qualify_clause_nonreserved production. + EnterQualify_clause_nonreserved(c *Qualify_clause_nonreservedContext) + + // EnterUnpivot_clause is called when entering the unpivot_clause production. + EnterUnpivot_clause(c *Unpivot_clauseContext) + + // EnterUnpivot_in_item_list is called when entering the unpivot_in_item_list production. + EnterUnpivot_in_item_list(c *Unpivot_in_item_listContext) + + // EnterUnpivot_in_item_list_prefix is called when entering the unpivot_in_item_list_prefix production. + EnterUnpivot_in_item_list_prefix(c *Unpivot_in_item_list_prefixContext) + + // EnterUnpivot_in_item is called when entering the unpivot_in_item production. + EnterUnpivot_in_item(c *Unpivot_in_itemContext) + + // EnterOpt_as_string_or_integer is called when entering the opt_as_string_or_integer production. + EnterOpt_as_string_or_integer(c *Opt_as_string_or_integerContext) + + // EnterPath_expression_list_with_opt_parens is called when entering the path_expression_list_with_opt_parens production. + EnterPath_expression_list_with_opt_parens(c *Path_expression_list_with_opt_parensContext) + + // EnterPath_expression_list is called when entering the path_expression_list production. + EnterPath_expression_list(c *Path_expression_listContext) + + // EnterUnpivot_nulls_filter is called when entering the unpivot_nulls_filter production. + EnterUnpivot_nulls_filter(c *Unpivot_nulls_filterContext) + + // EnterPivot_clause is called when entering the pivot_clause production. + EnterPivot_clause(c *Pivot_clauseContext) + + // EnterPivot_expression_list is called when entering the pivot_expression_list production. + EnterPivot_expression_list(c *Pivot_expression_listContext) + + // EnterPivot_expression is called when entering the pivot_expression production. + EnterPivot_expression(c *Pivot_expressionContext) + + // EnterPivot_value_list is called when entering the pivot_value_list production. + EnterPivot_value_list(c *Pivot_value_listContext) + + // EnterPivot_value is called when entering the pivot_value production. + EnterPivot_value(c *Pivot_valueContext) + + // EnterTvf_prefix_no_args is called when entering the tvf_prefix_no_args production. + EnterTvf_prefix_no_args(c *Tvf_prefix_no_argsContext) + + // EnterJoin_type is called when entering the join_type production. + EnterJoin_type(c *Join_typeContext) + + // EnterOpt_natural is called when entering the opt_natural production. + EnterOpt_natural(c *Opt_naturalContext) + + // EnterOn_clause is called when entering the on_clause production. + EnterOn_clause(c *On_clauseContext) + + // EnterSelect_list is called when entering the select_list production. + EnterSelect_list(c *Select_listContext) + + // EnterSelect_list_item is called when entering the select_list_item production. + EnterSelect_list_item(c *Select_list_itemContext) + + // EnterSelect_column_star is called when entering the select_column_star production. + EnterSelect_column_star(c *Select_column_starContext) + + // EnterSelect_column_expr is called when entering the select_column_expr production. + EnterSelect_column_expr(c *Select_column_exprContext) + + // EnterSelect_column_dot_star is called when entering the select_column_dot_star production. + EnterSelect_column_dot_star(c *Select_column_dot_starContext) + + // EnterStar_modifiers is called when entering the star_modifiers production. + EnterStar_modifiers(c *Star_modifiersContext) + + // EnterStar_except_list is called when entering the star_except_list production. + EnterStar_except_list(c *Star_except_listContext) + + // EnterStar_replace_list is called when entering the star_replace_list production. + EnterStar_replace_list(c *Star_replace_listContext) + + // EnterStar_replace_item is called when entering the star_replace_item production. + EnterStar_replace_item(c *Star_replace_itemContext) + + // EnterExpression is called when entering the expression production. + EnterExpression(c *ExpressionContext) + + // EnterExpression_higher_prec_than_and is called when entering the expression_higher_prec_than_and production. + EnterExpression_higher_prec_than_and(c *Expression_higher_prec_than_andContext) + + // EnterExpression_maybe_parenthesized_not_a_query is called when entering the expression_maybe_parenthesized_not_a_query production. + EnterExpression_maybe_parenthesized_not_a_query(c *Expression_maybe_parenthesized_not_a_queryContext) + + // EnterParenthesized_in_rhs is called when entering the parenthesized_in_rhs production. + EnterParenthesized_in_rhs(c *Parenthesized_in_rhsContext) + + // EnterUnary_operator is called when entering the unary_operator production. + EnterUnary_operator(c *Unary_operatorContext) + + // EnterComparative_operator is called when entering the comparative_operator production. + EnterComparative_operator(c *Comparative_operatorContext) + + // EnterShift_operator is called when entering the shift_operator production. + EnterShift_operator(c *Shift_operatorContext) + + // EnterAdditive_operator is called when entering the additive_operator production. + EnterAdditive_operator(c *Additive_operatorContext) + + // EnterMultiplicative_operator is called when entering the multiplicative_operator production. + EnterMultiplicative_operator(c *Multiplicative_operatorContext) + + // EnterIs_operator is called when entering the is_operator production. + EnterIs_operator(c *Is_operatorContext) + + // EnterBetween_operator is called when entering the between_operator production. + EnterBetween_operator(c *Between_operatorContext) + + // EnterIn_operator is called when entering the in_operator production. + EnterIn_operator(c *In_operatorContext) + + // EnterDistinct_operator is called when entering the distinct_operator production. + EnterDistinct_operator(c *Distinct_operatorContext) + + // EnterParenthesized_query is called when entering the parenthesized_query production. + EnterParenthesized_query(c *Parenthesized_queryContext) + + // EnterParenthesized_expression_not_a_query is called when entering the parenthesized_expression_not_a_query production. + EnterParenthesized_expression_not_a_query(c *Parenthesized_expression_not_a_queryContext) + + // EnterParenthesized_anysomeall_list_in_rhs is called when entering the parenthesized_anysomeall_list_in_rhs production. + EnterParenthesized_anysomeall_list_in_rhs(c *Parenthesized_anysomeall_list_in_rhsContext) + + // EnterAnd_expression is called when entering the and_expression production. + EnterAnd_expression(c *And_expressionContext) + + // EnterIn_list_two_or_more_prefix is called when entering the in_list_two_or_more_prefix production. + EnterIn_list_two_or_more_prefix(c *In_list_two_or_more_prefixContext) + + // EnterAny_some_all is called when entering the any_some_all production. + EnterAny_some_all(c *Any_some_allContext) + + // EnterLike_operator is called when entering the like_operator production. + EnterLike_operator(c *Like_operatorContext) + + // EnterExpression_subquery_with_keyword is called when entering the expression_subquery_with_keyword production. + EnterExpression_subquery_with_keyword(c *Expression_subquery_with_keywordContext) + + // EnterStruct_constructor is called when entering the struct_constructor production. + EnterStruct_constructor(c *Struct_constructorContext) + + // EnterStruct_constructor_prefix_with_keyword is called when entering the struct_constructor_prefix_with_keyword production. + EnterStruct_constructor_prefix_with_keyword(c *Struct_constructor_prefix_with_keywordContext) + + // EnterStruct_constructor_arg is called when entering the struct_constructor_arg production. + EnterStruct_constructor_arg(c *Struct_constructor_argContext) + + // EnterStruct_constructor_prefix_without_keyword is called when entering the struct_constructor_prefix_without_keyword production. + EnterStruct_constructor_prefix_without_keyword(c *Struct_constructor_prefix_without_keywordContext) + + // EnterStruct_constructor_prefix_with_keyword_no_arg is called when entering the struct_constructor_prefix_with_keyword_no_arg production. + EnterStruct_constructor_prefix_with_keyword_no_arg(c *Struct_constructor_prefix_with_keyword_no_argContext) + + // EnterInterval_expression is called when entering the interval_expression production. + EnterInterval_expression(c *Interval_expressionContext) + + // EnterFunction_call_expression_with_clauses is called when entering the function_call_expression_with_clauses production. + EnterFunction_call_expression_with_clauses(c *Function_call_expression_with_clausesContext) + + // EnterFunction_call_expression_with_clauses_suffix is called when entering the function_call_expression_with_clauses_suffix production. + EnterFunction_call_expression_with_clauses_suffix(c *Function_call_expression_with_clauses_suffixContext) + + // EnterOver_clause is called when entering the over_clause production. + EnterOver_clause(c *Over_clauseContext) + + // EnterWindow_specification is called when entering the window_specification production. + EnterWindow_specification(c *Window_specificationContext) + + // EnterOpt_window_frame_clause is called when entering the opt_window_frame_clause production. + EnterOpt_window_frame_clause(c *Opt_window_frame_clauseContext) + + // EnterWindow_frame_bound is called when entering the window_frame_bound production. + EnterWindow_frame_bound(c *Window_frame_boundContext) + + // EnterPreceding_or_following is called when entering the preceding_or_following production. + EnterPreceding_or_following(c *Preceding_or_followingContext) + + // EnterFrame_unit is called when entering the frame_unit production. + EnterFrame_unit(c *Frame_unitContext) + + // EnterPartition_by_clause is called when entering the partition_by_clause production. + EnterPartition_by_clause(c *Partition_by_clauseContext) + + // EnterPartition_by_clause_prefix is called when entering the partition_by_clause_prefix production. + EnterPartition_by_clause_prefix(c *Partition_by_clause_prefixContext) + + // EnterWith_group_rows is called when entering the with_group_rows production. + EnterWith_group_rows(c *With_group_rowsContext) + + // EnterWith_report_modifier is called when entering the with_report_modifier production. + EnterWith_report_modifier(c *With_report_modifierContext) + + // EnterClamped_between_modifier is called when entering the clamped_between_modifier production. + EnterClamped_between_modifier(c *Clamped_between_modifierContext) + + // EnterWith_report_format is called when entering the with_report_format production. + EnterWith_report_format(c *With_report_formatContext) + + // EnterOptions_list is called when entering the options_list production. + EnterOptions_list(c *Options_listContext) + + // EnterOptions_list_prefix is called when entering the options_list_prefix production. + EnterOptions_list_prefix(c *Options_list_prefixContext) + + // EnterOptions_entry is called when entering the options_entry production. + EnterOptions_entry(c *Options_entryContext) + + // EnterExpression_or_proto is called when entering the expression_or_proto production. + EnterExpression_or_proto(c *Expression_or_protoContext) + + // EnterOptions_assignment_operator is called when entering the options_assignment_operator production. + EnterOptions_assignment_operator(c *Options_assignment_operatorContext) + + // EnterOpt_null_handling_modifier is called when entering the opt_null_handling_modifier production. + EnterOpt_null_handling_modifier(c *Opt_null_handling_modifierContext) + + // EnterFunction_call_argument is called when entering the function_call_argument production. + EnterFunction_call_argument(c *Function_call_argumentContext) + + // EnterSequence_arg is called when entering the sequence_arg production. + EnterSequence_arg(c *Sequence_argContext) + + // EnterNamed_argument is called when entering the named_argument production. + EnterNamed_argument(c *Named_argumentContext) + + // EnterLambda_argument is called when entering the lambda_argument production. + EnterLambda_argument(c *Lambda_argumentContext) + + // EnterLambda_argument_list is called when entering the lambda_argument_list production. + EnterLambda_argument_list(c *Lambda_argument_listContext) + + // EnterLimit_offset_clause is called when entering the limit_offset_clause production. + EnterLimit_offset_clause(c *Limit_offset_clauseContext) + + // EnterOpt_having_or_group_by_modifier is called when entering the opt_having_or_group_by_modifier production. + EnterOpt_having_or_group_by_modifier(c *Opt_having_or_group_by_modifierContext) + + // EnterGroup_by_clause_prefix is called when entering the group_by_clause_prefix production. + EnterGroup_by_clause_prefix(c *Group_by_clause_prefixContext) + + // EnterGroup_by_preamble is called when entering the group_by_preamble production. + EnterGroup_by_preamble(c *Group_by_preambleContext) + + // EnterOpt_and_order is called when entering the opt_and_order production. + EnterOpt_and_order(c *Opt_and_orderContext) + + // EnterHint is called when entering the hint production. + EnterHint(c *HintContext) + + // EnterHint_with_body is called when entering the hint_with_body production. + EnterHint_with_body(c *Hint_with_bodyContext) + + // EnterHint_with_body_prefix is called when entering the hint_with_body_prefix production. + EnterHint_with_body_prefix(c *Hint_with_body_prefixContext) + + // EnterHint_entry is called when entering the hint_entry production. + EnterHint_entry(c *Hint_entryContext) + + // EnterIdentifier_in_hints is called when entering the identifier_in_hints production. + EnterIdentifier_in_hints(c *Identifier_in_hintsContext) + + // EnterExtra_identifier_in_hints_name is called when entering the extra_identifier_in_hints_name production. + EnterExtra_identifier_in_hints_name(c *Extra_identifier_in_hints_nameContext) + + // EnterGrouping_item is called when entering the grouping_item production. + EnterGrouping_item(c *Grouping_itemContext) + + // EnterGrouping_set_list is called when entering the grouping_set_list production. + EnterGrouping_set_list(c *Grouping_set_listContext) + + // EnterGrouping_set is called when entering the grouping_set production. + EnterGrouping_set(c *Grouping_setContext) + + // EnterCube_list is called when entering the cube_list production. + EnterCube_list(c *Cube_listContext) + + // EnterRollup_list is called when entering the rollup_list production. + EnterRollup_list(c *Rollup_listContext) + + // EnterOpt_as_alias_with_required_as is called when entering the opt_as_alias_with_required_as production. + EnterOpt_as_alias_with_required_as(c *Opt_as_alias_with_required_asContext) + + // EnterOpt_grouping_item_order is called when entering the opt_grouping_item_order production. + EnterOpt_grouping_item_order(c *Opt_grouping_item_orderContext) + + // EnterOpt_selection_item_order is called when entering the opt_selection_item_order production. + EnterOpt_selection_item_order(c *Opt_selection_item_orderContext) + + // EnterAsc_or_desc is called when entering the asc_or_desc production. + EnterAsc_or_desc(c *Asc_or_descContext) + + // EnterNull_order is called when entering the null_order production. + EnterNull_order(c *Null_orderContext) + + // EnterFunction_name_from_keyword is called when entering the function_name_from_keyword production. + EnterFunction_name_from_keyword(c *Function_name_from_keywordContext) + + // EnterReplace_fields_expression is called when entering the replace_fields_expression production. + EnterReplace_fields_expression(c *Replace_fields_expressionContext) + + // EnterReplace_fields_prefix is called when entering the replace_fields_prefix production. + EnterReplace_fields_prefix(c *Replace_fields_prefixContext) + + // EnterReplace_fields_arg is called when entering the replace_fields_arg production. + EnterReplace_fields_arg(c *Replace_fields_argContext) + + // EnterGeneralized_path_expression is called when entering the generalized_path_expression production. + EnterGeneralized_path_expression(c *Generalized_path_expressionContext) + + // EnterGeneralized_extension_path is called when entering the generalized_extension_path production. + EnterGeneralized_extension_path(c *Generalized_extension_pathContext) + + // EnterWith_expression is called when entering the with_expression production. + EnterWith_expression(c *With_expressionContext) + + // EnterWith_expression_variable_prefix is called when entering the with_expression_variable_prefix production. + EnterWith_expression_variable_prefix(c *With_expression_variable_prefixContext) + + // EnterWith_expression_variable is called when entering the with_expression_variable production. + EnterWith_expression_variable(c *With_expression_variableContext) + + // EnterExtract_expression is called when entering the extract_expression production. + EnterExtract_expression(c *Extract_expressionContext) + + // EnterExtract_expression_base is called when entering the extract_expression_base production. + EnterExtract_expression_base(c *Extract_expression_baseContext) + + // EnterOpt_format is called when entering the opt_format production. + EnterOpt_format(c *Opt_formatContext) + + // EnterOpt_at_time_zone is called when entering the opt_at_time_zone production. + EnterOpt_at_time_zone(c *Opt_at_time_zoneContext) + + // EnterCast_expression is called when entering the cast_expression production. + EnterCast_expression(c *Cast_expressionContext) + + // EnterCase_expression is called when entering the case_expression production. + EnterCase_expression(c *Case_expressionContext) + + // EnterCase_expression_prefix is called when entering the case_expression_prefix production. + EnterCase_expression_prefix(c *Case_expression_prefixContext) + + // EnterCase_value_expression_prefix is called when entering the case_value_expression_prefix production. + EnterCase_value_expression_prefix(c *Case_value_expression_prefixContext) + + // EnterCase_no_value_expression_prefix is called when entering the case_no_value_expression_prefix production. + EnterCase_no_value_expression_prefix(c *Case_no_value_expression_prefixContext) + + // EnterStruct_braced_constructor is called when entering the struct_braced_constructor production. + EnterStruct_braced_constructor(c *Struct_braced_constructorContext) + + // EnterBraced_new_constructor is called when entering the braced_new_constructor production. + EnterBraced_new_constructor(c *Braced_new_constructorContext) + + // EnterBraced_constructor is called when entering the braced_constructor production. + EnterBraced_constructor(c *Braced_constructorContext) + + // EnterBraced_constructor_start is called when entering the braced_constructor_start production. + EnterBraced_constructor_start(c *Braced_constructor_startContext) + + // EnterBraced_constructor_prefix is called when entering the braced_constructor_prefix production. + EnterBraced_constructor_prefix(c *Braced_constructor_prefixContext) + + // EnterBraced_constructor_field is called when entering the braced_constructor_field production. + EnterBraced_constructor_field(c *Braced_constructor_fieldContext) + + // EnterBraced_constructor_lhs is called when entering the braced_constructor_lhs production. + EnterBraced_constructor_lhs(c *Braced_constructor_lhsContext) + + // EnterBraced_constructor_field_value is called when entering the braced_constructor_field_value production. + EnterBraced_constructor_field_value(c *Braced_constructor_field_valueContext) + + // EnterBraced_constructor_extension is called when entering the braced_constructor_extension production. + EnterBraced_constructor_extension(c *Braced_constructor_extensionContext) + + // EnterNew_constructor is called when entering the new_constructor production. + EnterNew_constructor(c *New_constructorContext) + + // EnterNew_constructor_prefix is called when entering the new_constructor_prefix production. + EnterNew_constructor_prefix(c *New_constructor_prefixContext) + + // EnterNew_constructor_prefix_no_arg is called when entering the new_constructor_prefix_no_arg production. + EnterNew_constructor_prefix_no_arg(c *New_constructor_prefix_no_argContext) + + // EnterNew_constructor_arg is called when entering the new_constructor_arg production. + EnterNew_constructor_arg(c *New_constructor_argContext) + + // EnterArray_constructor is called when entering the array_constructor production. + EnterArray_constructor(c *Array_constructorContext) + + // EnterArray_constructor_prefix is called when entering the array_constructor_prefix production. + EnterArray_constructor_prefix(c *Array_constructor_prefixContext) + + // EnterArray_constructor_prefix_no_expressions is called when entering the array_constructor_prefix_no_expressions production. + EnterArray_constructor_prefix_no_expressions(c *Array_constructor_prefix_no_expressionsContext) + + // EnterRange_literal is called when entering the range_literal production. + EnterRange_literal(c *Range_literalContext) + + // EnterRange_type is called when entering the range_type production. + EnterRange_type(c *Range_typeContext) + + // EnterType is called when entering the type production. + EnterType(c *TypeContext) + + // EnterCollate_clause is called when entering the collate_clause production. + EnterCollate_clause(c *Collate_clauseContext) + + // EnterString_literal_or_parameter is called when entering the string_literal_or_parameter production. + EnterString_literal_or_parameter(c *String_literal_or_parameterContext) + + // EnterSystem_variable_expression is called when entering the system_variable_expression production. + EnterSystem_variable_expression(c *System_variable_expressionContext) + + // EnterParameter_expression is called when entering the parameter_expression production. + EnterParameter_expression(c *Parameter_expressionContext) + + // EnterNamed_parameter_expression is called when entering the named_parameter_expression production. + EnterNamed_parameter_expression(c *Named_parameter_expressionContext) + + // EnterOpt_type_parameters is called when entering the opt_type_parameters production. + EnterOpt_type_parameters(c *Opt_type_parametersContext) + + // EnterType_parameters_prefix is called when entering the type_parameters_prefix production. + EnterType_parameters_prefix(c *Type_parameters_prefixContext) + + // EnterType_parameter is called when entering the type_parameter production. + EnterType_parameter(c *Type_parameterContext) + + // EnterRaw_type is called when entering the raw_type production. + EnterRaw_type(c *Raw_typeContext) + + // EnterMap_type is called when entering the map_type production. + EnterMap_type(c *Map_typeContext) + + // EnterFunction_type is called when entering the function_type production. + EnterFunction_type(c *Function_typeContext) + + // EnterFunction_type_prefix is called when entering the function_type_prefix production. + EnterFunction_type_prefix(c *Function_type_prefixContext) + + // EnterType_name is called when entering the type_name production. + EnterType_name(c *Type_nameContext) + + // EnterPath_expression is called when entering the path_expression production. + EnterPath_expression(c *Path_expressionContext) + + // EnterIdentifier is called when entering the identifier production. + EnterIdentifier(c *IdentifierContext) + + // EnterKeyword_as_identifier is called when entering the keyword_as_identifier production. + EnterKeyword_as_identifier(c *Keyword_as_identifierContext) + + // EnterCommon_keyword_as_identifier is called when entering the common_keyword_as_identifier production. + EnterCommon_keyword_as_identifier(c *Common_keyword_as_identifierContext) + + // EnterToken_identifier is called when entering the token_identifier production. + EnterToken_identifier(c *Token_identifierContext) + + // EnterStruct_type is called when entering the struct_type production. + EnterStruct_type(c *Struct_typeContext) + + // EnterStruct_type_prefix is called when entering the struct_type_prefix production. + EnterStruct_type_prefix(c *Struct_type_prefixContext) + + // EnterStruct_field is called when entering the struct_field production. + EnterStruct_field(c *Struct_fieldContext) + + // EnterArray_type is called when entering the array_type production. + EnterArray_type(c *Array_typeContext) + + // EnterTemplate_type_open is called when entering the template_type_open production. + EnterTemplate_type_open(c *Template_type_openContext) + + // EnterTemplate_type_close is called when entering the template_type_close production. + EnterTemplate_type_close(c *Template_type_closeContext) + + // EnterDate_or_time_literal is called when entering the date_or_time_literal production. + EnterDate_or_time_literal(c *Date_or_time_literalContext) + + // EnterDate_or_time_literal_kind is called when entering the date_or_time_literal_kind production. + EnterDate_or_time_literal_kind(c *Date_or_time_literal_kindContext) + + // EnterFloating_point_literal is called when entering the floating_point_literal production. + EnterFloating_point_literal(c *Floating_point_literalContext) + + // EnterJson_literal is called when entering the json_literal production. + EnterJson_literal(c *Json_literalContext) + + // EnterBignumeric_literal is called when entering the bignumeric_literal production. + EnterBignumeric_literal(c *Bignumeric_literalContext) + + // EnterBignumeric_literal_prefix is called when entering the bignumeric_literal_prefix production. + EnterBignumeric_literal_prefix(c *Bignumeric_literal_prefixContext) + + // EnterNumeric_literal is called when entering the numeric_literal production. + EnterNumeric_literal(c *Numeric_literalContext) + + // EnterNumeric_literal_prefix is called when entering the numeric_literal_prefix production. + EnterNumeric_literal_prefix(c *Numeric_literal_prefixContext) + + // EnterInteger_literal is called when entering the integer_literal production. + EnterInteger_literal(c *Integer_literalContext) + + // EnterBytes_literal is called when entering the bytes_literal production. + EnterBytes_literal(c *Bytes_literalContext) + + // EnterNull_literal is called when entering the null_literal production. + EnterNull_literal(c *Null_literalContext) + + // EnterBoolean_literal is called when entering the boolean_literal production. + EnterBoolean_literal(c *Boolean_literalContext) + + // EnterString_literal is called when entering the string_literal production. + EnterString_literal(c *String_literalContext) + + // EnterString_literal_component is called when entering the string_literal_component production. + EnterString_literal_component(c *String_literal_componentContext) + + // EnterBytes_literal_component is called when entering the bytes_literal_component production. + EnterBytes_literal_component(c *Bytes_literal_componentContext) + + // ExitRoot is called when exiting the root production. + ExitRoot(c *RootContext) + + // ExitStmts is called when exiting the stmts production. + ExitStmts(c *StmtsContext) + + // ExitUnterminated_sql_statement is called when exiting the unterminated_sql_statement production. + ExitUnterminated_sql_statement(c *Unterminated_sql_statementContext) + + // ExitSql_statement_body is called when exiting the sql_statement_body production. + ExitSql_statement_body(c *Sql_statement_bodyContext) + + // ExitGql_statement is called when exiting the gql_statement production. + ExitGql_statement(c *Gql_statementContext) + + // ExitGraph_operation_block is called when exiting the graph_operation_block production. + ExitGraph_operation_block(c *Graph_operation_blockContext) + + // ExitGraph_composite_query_block is called when exiting the graph_composite_query_block production. + ExitGraph_composite_query_block(c *Graph_composite_query_blockContext) + + // ExitGraph_composite_query_prefix is called when exiting the graph_composite_query_prefix production. + ExitGraph_composite_query_prefix(c *Graph_composite_query_prefixContext) + + // ExitGraph_set_operation_metadata is called when exiting the graph_set_operation_metadata production. + ExitGraph_set_operation_metadata(c *Graph_set_operation_metadataContext) + + // ExitGraph_linear_query_operation is called when exiting the graph_linear_query_operation production. + ExitGraph_linear_query_operation(c *Graph_linear_query_operationContext) + + // ExitGraph_linear_operator_list is called when exiting the graph_linear_operator_list production. + ExitGraph_linear_operator_list(c *Graph_linear_operator_listContext) + + // ExitGraph_linear_operator is called when exiting the graph_linear_operator production. + ExitGraph_linear_operator(c *Graph_linear_operatorContext) + + // ExitGraph_sample_clause is called when exiting the graph_sample_clause production. + ExitGraph_sample_clause(c *Graph_sample_clauseContext) + + // ExitOpt_graph_sample_clause_suffix is called when exiting the opt_graph_sample_clause_suffix production. + ExitOpt_graph_sample_clause_suffix(c *Opt_graph_sample_clause_suffixContext) + + // ExitGraph_for_operator is called when exiting the graph_for_operator production. + ExitGraph_for_operator(c *Graph_for_operatorContext) + + // ExitOpt_with_offset_and_alias_with_required_as is called when exiting the opt_with_offset_and_alias_with_required_as production. + ExitOpt_with_offset_and_alias_with_required_as(c *Opt_with_offset_and_alias_with_required_asContext) + + // ExitGraph_with_operator is called when exiting the graph_with_operator production. + ExitGraph_with_operator(c *Graph_with_operatorContext) + + // ExitGraph_page_operator is called when exiting the graph_page_operator production. + ExitGraph_page_operator(c *Graph_page_operatorContext) + + // ExitGraph_order_by_operator is called when exiting the graph_order_by_operator production. + ExitGraph_order_by_operator(c *Graph_order_by_operatorContext) + + // ExitGraph_filter_operator is called when exiting the graph_filter_operator production. + ExitGraph_filter_operator(c *Graph_filter_operatorContext) + + // ExitGraph_let_operator is called when exiting the graph_let_operator production. + ExitGraph_let_operator(c *Graph_let_operatorContext) + + // ExitGraph_let_variable_definition_list is called when exiting the graph_let_variable_definition_list production. + ExitGraph_let_variable_definition_list(c *Graph_let_variable_definition_listContext) + + // ExitGraph_let_variable_definition is called when exiting the graph_let_variable_definition production. + ExitGraph_let_variable_definition(c *Graph_let_variable_definitionContext) + + // ExitGraph_optional_match_operator is called when exiting the graph_optional_match_operator production. + ExitGraph_optional_match_operator(c *Graph_optional_match_operatorContext) + + // ExitGraph_match_operator is called when exiting the graph_match_operator production. + ExitGraph_match_operator(c *Graph_match_operatorContext) + + // ExitGraph_pattern is called when exiting the graph_pattern production. + ExitGraph_pattern(c *Graph_patternContext) + + // ExitGraph_path_pattern_list is called when exiting the graph_path_pattern_list production. + ExitGraph_path_pattern_list(c *Graph_path_pattern_listContext) + + // ExitGraph_path_pattern is called when exiting the graph_path_pattern production. + ExitGraph_path_pattern(c *Graph_path_patternContext) + + // ExitGraph_path_pattern_expr is called when exiting the graph_path_pattern_expr production. + ExitGraph_path_pattern_expr(c *Graph_path_pattern_exprContext) + + // ExitGraph_path_factor is called when exiting the graph_path_factor production. + ExitGraph_path_factor(c *Graph_path_factorContext) + + // ExitGraph_quantified_path_primary is called when exiting the graph_quantified_path_primary production. + ExitGraph_quantified_path_primary(c *Graph_quantified_path_primaryContext) + + // ExitGraph_path_primary is called when exiting the graph_path_primary production. + ExitGraph_path_primary(c *Graph_path_primaryContext) + + // ExitGraph_parenthesized_path_pattern is called when exiting the graph_parenthesized_path_pattern production. + ExitGraph_parenthesized_path_pattern(c *Graph_parenthesized_path_patternContext) + + // ExitGraph_element_pattern is called when exiting the graph_element_pattern production. + ExitGraph_element_pattern(c *Graph_element_patternContext) + + // ExitGraph_edge_pattern is called when exiting the graph_edge_pattern production. + ExitGraph_edge_pattern(c *Graph_edge_patternContext) + + // ExitGraph_node_pattern is called when exiting the graph_node_pattern production. + ExitGraph_node_pattern(c *Graph_node_patternContext) + + // ExitGraph_element_pattern_filler is called when exiting the graph_element_pattern_filler production. + ExitGraph_element_pattern_filler(c *Graph_element_pattern_fillerContext) + + // ExitGraph_property_specification is called when exiting the graph_property_specification production. + ExitGraph_property_specification(c *Graph_property_specificationContext) + + // ExitGraph_property_name_and_value is called when exiting the graph_property_name_and_value production. + ExitGraph_property_name_and_value(c *Graph_property_name_and_valueContext) + + // ExitOpt_is_label_expression is called when exiting the opt_is_label_expression production. + ExitOpt_is_label_expression(c *Opt_is_label_expressionContext) + + // ExitLabel_expression is called when exiting the label_expression production. + ExitLabel_expression(c *Label_expressionContext) + + // ExitLabel_primary is called when exiting the label_primary production. + ExitLabel_primary(c *Label_primaryContext) + + // ExitParenthesized_label_expression is called when exiting the parenthesized_label_expression production. + ExitParenthesized_label_expression(c *Parenthesized_label_expressionContext) + + // ExitOpt_graph_element_identifier is called when exiting the opt_graph_element_identifier production. + ExitOpt_graph_element_identifier(c *Opt_graph_element_identifierContext) + + // ExitOpt_graph_path_mode_prefix is called when exiting the opt_graph_path_mode_prefix production. + ExitOpt_graph_path_mode_prefix(c *Opt_graph_path_mode_prefixContext) + + // ExitPath_or_paths is called when exiting the path_or_paths production. + ExitPath_or_paths(c *Path_or_pathsContext) + + // ExitOpt_graph_path_mode is called when exiting the opt_graph_path_mode production. + ExitOpt_graph_path_mode(c *Opt_graph_path_modeContext) + + // ExitOpt_graph_search_prefix is called when exiting the opt_graph_search_prefix production. + ExitOpt_graph_search_prefix(c *Opt_graph_search_prefixContext) + + // ExitOpt_path_variable_assignment is called when exiting the opt_path_variable_assignment production. + ExitOpt_path_variable_assignment(c *Opt_path_variable_assignmentContext) + + // ExitGraph_identifier is called when exiting the graph_identifier production. + ExitGraph_identifier(c *Graph_identifierContext) + + // ExitGraph_return_operator is called when exiting the graph_return_operator production. + ExitGraph_return_operator(c *Graph_return_operatorContext) + + // ExitGraph_page_clause is called when exiting the graph_page_clause production. + ExitGraph_page_clause(c *Graph_page_clauseContext) + + // ExitGraph_order_by_clause is called when exiting the graph_order_by_clause production. + ExitGraph_order_by_clause(c *Graph_order_by_clauseContext) + + // ExitGraph_ordering_expression is called when exiting the graph_ordering_expression production. + ExitGraph_ordering_expression(c *Graph_ordering_expressionContext) + + // ExitOpt_graph_asc_or_desc is called when exiting the opt_graph_asc_or_desc production. + ExitOpt_graph_asc_or_desc(c *Opt_graph_asc_or_descContext) + + // ExitGraph_return_item_list is called when exiting the graph_return_item_list production. + ExitGraph_return_item_list(c *Graph_return_item_listContext) + + // ExitGraph_return_item is called when exiting the graph_return_item production. + ExitGraph_return_item(c *Graph_return_itemContext) + + // ExitUndrop_statement is called when exiting the undrop_statement production. + ExitUndrop_statement(c *Undrop_statementContext) + + // ExitModule_statement is called when exiting the module_statement production. + ExitModule_statement(c *Module_statementContext) + + // ExitImport_statement is called when exiting the import_statement production. + ExitImport_statement(c *Import_statementContext) + + // ExitOpt_as_or_into_alias is called when exiting the opt_as_or_into_alias production. + ExitOpt_as_or_into_alias(c *Opt_as_or_into_aliasContext) + + // ExitPath_expression_or_string is called when exiting the path_expression_or_string production. + ExitPath_expression_or_string(c *Path_expression_or_stringContext) + + // ExitImport_type is called when exiting the import_type production. + ExitImport_type(c *Import_typeContext) + + // ExitCall_statement is called when exiting the call_statement production. + ExitCall_statement(c *Call_statementContext) + + // ExitDrop_statement is called when exiting the drop_statement production. + ExitDrop_statement(c *Drop_statementContext) + + // ExitOpt_drop_mode is called when exiting the opt_drop_mode production. + ExitOpt_drop_mode(c *Opt_drop_modeContext) + + // ExitDrop_all_row_access_policies_statement is called when exiting the drop_all_row_access_policies_statement production. + ExitDrop_all_row_access_policies_statement(c *Drop_all_row_access_policies_statementContext) + + // ExitShow_statement is called when exiting the show_statement production. + ExitShow_statement(c *Show_statementContext) + + // ExitOpt_like_string_literal is called when exiting the opt_like_string_literal production. + ExitOpt_like_string_literal(c *Opt_like_string_literalContext) + + // ExitShow_target is called when exiting the show_target production. + ExitShow_target(c *Show_targetContext) + + // ExitRename_statement is called when exiting the rename_statement production. + ExitRename_statement(c *Rename_statementContext) + + // ExitRevoke_statement is called when exiting the revoke_statement production. + ExitRevoke_statement(c *Revoke_statementContext) + + // ExitGrant_statement is called when exiting the grant_statement production. + ExitGrant_statement(c *Grant_statementContext) + + // ExitPrivileges is called when exiting the privileges production. + ExitPrivileges(c *PrivilegesContext) + + // ExitExport_metadata_statement is called when exiting the export_metadata_statement production. + ExitExport_metadata_statement(c *Export_metadata_statementContext) + + // ExitExport_model_statement is called when exiting the export_model_statement production. + ExitExport_model_statement(c *Export_model_statementContext) + + // ExitExport_data_statement is called when exiting the export_data_statement production. + ExitExport_data_statement(c *Export_data_statementContext) + + // ExitExport_data_no_query is called when exiting the export_data_no_query production. + ExitExport_data_no_query(c *Export_data_no_queryContext) + + // ExitExplain_statement is called when exiting the explain_statement production. + ExitExplain_statement(c *Explain_statementContext) + + // ExitExecute_immediate is called when exiting the execute_immediate production. + ExitExecute_immediate(c *Execute_immediateContext) + + // ExitOpt_execute_into_clause is called when exiting the opt_execute_into_clause production. + ExitOpt_execute_into_clause(c *Opt_execute_into_clauseContext) + + // ExitOpt_execute_using_clause is called when exiting the opt_execute_using_clause production. + ExitOpt_execute_using_clause(c *Opt_execute_using_clauseContext) + + // ExitExecute_using_argument_list is called when exiting the execute_using_argument_list production. + ExitExecute_using_argument_list(c *Execute_using_argument_listContext) + + // ExitExecute_using_argument is called when exiting the execute_using_argument production. + ExitExecute_using_argument(c *Execute_using_argumentContext) + + // ExitDescribe_statement is called when exiting the describe_statement production. + ExitDescribe_statement(c *Describe_statementContext) + + // ExitDescribe_info is called when exiting the describe_info production. + ExitDescribe_info(c *Describe_infoContext) + + // ExitOpt_from_path_expression is called when exiting the opt_from_path_expression production. + ExitOpt_from_path_expression(c *Opt_from_path_expressionContext) + + // ExitDescribe_keyword is called when exiting the describe_keyword production. + ExitDescribe_keyword(c *Describe_keywordContext) + + // ExitDefine_table_statement is called when exiting the define_table_statement production. + ExitDefine_table_statement(c *Define_table_statementContext) + + // ExitCreate_entity_statement is called when exiting the create_entity_statement production. + ExitCreate_entity_statement(c *Create_entity_statementContext) + + // ExitOpt_generic_entity_body is called when exiting the opt_generic_entity_body production. + ExitOpt_generic_entity_body(c *Opt_generic_entity_bodyContext) + + // ExitCreate_view_statement is called when exiting the create_view_statement production. + ExitCreate_view_statement(c *Create_view_statementContext) + + // ExitQuery_or_replica_source is called when exiting the query_or_replica_source production. + ExitQuery_or_replica_source(c *Query_or_replica_sourceContext) + + // ExitColumn_with_options_list is called when exiting the column_with_options_list production. + ExitColumn_with_options_list(c *Column_with_options_listContext) + + // ExitColumn_with_options is called when exiting the column_with_options production. + ExitColumn_with_options(c *Column_with_optionsContext) + + // ExitCreate_table_statement is called when exiting the create_table_statement production. + ExitCreate_table_statement(c *Create_table_statementContext) + + // ExitOpt_ttl_clause is called when exiting the opt_ttl_clause production. + ExitOpt_ttl_clause(c *Opt_ttl_clauseContext) + + // ExitOpt_copy_table is called when exiting the opt_copy_table production. + ExitOpt_copy_table(c *Opt_copy_tableContext) + + // ExitCopy_data_source is called when exiting the copy_data_source production. + ExitCopy_data_source(c *Copy_data_sourceContext) + + // ExitOpt_clone_table is called when exiting the opt_clone_table production. + ExitOpt_clone_table(c *Opt_clone_tableContext) + + // ExitOpt_spanner_table_options is called when exiting the opt_spanner_table_options production. + ExitOpt_spanner_table_options(c *Opt_spanner_table_optionsContext) + + // ExitOpt_spanner_interleave_in_parent_clause is called when exiting the opt_spanner_interleave_in_parent_clause production. + ExitOpt_spanner_interleave_in_parent_clause(c *Opt_spanner_interleave_in_parent_clauseContext) + + // ExitSpanner_primary_key is called when exiting the spanner_primary_key production. + ExitSpanner_primary_key(c *Spanner_primary_keyContext) + + // ExitCreate_table_function_statement is called when exiting the create_table_function_statement production. + ExitCreate_table_function_statement(c *Create_table_function_statementContext) + + // ExitOpt_as_query_or_string is called when exiting the opt_as_query_or_string production. + ExitOpt_as_query_or_string(c *Opt_as_query_or_stringContext) + + // ExitUnordered_language_options is called when exiting the unordered_language_options production. + ExitUnordered_language_options(c *Unordered_language_optionsContext) + + // ExitOpt_function_parameters is called when exiting the opt_function_parameters production. + ExitOpt_function_parameters(c *Opt_function_parametersContext) + + // ExitCreate_snapshot_statement is called when exiting the create_snapshot_statement production. + ExitCreate_snapshot_statement(c *Create_snapshot_statementContext) + + // ExitCreate_external_schema_statement is called when exiting the create_external_schema_statement production. + ExitCreate_external_schema_statement(c *Create_external_schema_statementContext) + + // ExitCreate_schema_statement is called when exiting the create_schema_statement production. + ExitCreate_schema_statement(c *Create_schema_statementContext) + + // ExitCreate_property_graph_statement is called when exiting the create_property_graph_statement production. + ExitCreate_property_graph_statement(c *Create_property_graph_statementContext) + + // ExitOpt_edge_table_clause is called when exiting the opt_edge_table_clause production. + ExitOpt_edge_table_clause(c *Opt_edge_table_clauseContext) + + // ExitElement_table_list is called when exiting the element_table_list production. + ExitElement_table_list(c *Element_table_listContext) + + // ExitElement_table_definition is called when exiting the element_table_definition production. + ExitElement_table_definition(c *Element_table_definitionContext) + + // ExitOpt_label_and_properties_clause is called when exiting the opt_label_and_properties_clause production. + ExitOpt_label_and_properties_clause(c *Opt_label_and_properties_clauseContext) + + // ExitLabel_and_properties_list is called when exiting the label_and_properties_list production. + ExitLabel_and_properties_list(c *Label_and_properties_listContext) + + // ExitLabel_and_properties is called when exiting the label_and_properties production. + ExitLabel_and_properties(c *Label_and_propertiesContext) + + // ExitProperties_clause is called when exiting the properties_clause production. + ExitProperties_clause(c *Properties_clauseContext) + + // ExitDerived_property_list is called when exiting the derived_property_list production. + ExitDerived_property_list(c *Derived_property_listContext) + + // ExitDerived_property is called when exiting the derived_property production. + ExitDerived_property(c *Derived_propertyContext) + + // ExitOpt_except_column_list is called when exiting the opt_except_column_list production. + ExitOpt_except_column_list(c *Opt_except_column_listContext) + + // ExitProperties_all_columns is called when exiting the properties_all_columns production. + ExitProperties_all_columns(c *Properties_all_columnsContext) + + // ExitOpt_dest_node_table_clause is called when exiting the opt_dest_node_table_clause production. + ExitOpt_dest_node_table_clause(c *Opt_dest_node_table_clauseContext) + + // ExitOpt_source_node_table_clause is called when exiting the opt_source_node_table_clause production. + ExitOpt_source_node_table_clause(c *Opt_source_node_table_clauseContext) + + // ExitOpt_key_clause is called when exiting the opt_key_clause production. + ExitOpt_key_clause(c *Opt_key_clauseContext) + + // ExitCreate_model_statement is called when exiting the create_model_statement production. + ExitCreate_model_statement(c *Create_model_statementContext) + + // ExitOpt_input_output_clause is called when exiting the opt_input_output_clause production. + ExitOpt_input_output_clause(c *Opt_input_output_clauseContext) + + // ExitOpt_transform_clause is called when exiting the opt_transform_clause production. + ExitOpt_transform_clause(c *Opt_transform_clauseContext) + + // ExitOpt_as_query_or_aliased_query_list is called when exiting the opt_as_query_or_aliased_query_list production. + ExitOpt_as_query_or_aliased_query_list(c *Opt_as_query_or_aliased_query_listContext) + + // ExitAliased_query_list is called when exiting the aliased_query_list production. + ExitAliased_query_list(c *Aliased_query_listContext) + + // ExitAs_query is called when exiting the as_query production. + ExitAs_query(c *As_queryContext) + + // ExitCreate_external_table_function_statement is called when exiting the create_external_table_function_statement production. + ExitCreate_external_table_function_statement(c *Create_external_table_function_statementContext) + + // ExitCreate_external_table_statement is called when exiting the create_external_table_statement production. + ExitCreate_external_table_statement(c *Create_external_table_statementContext) + + // ExitOpt_default_collate_clause is called when exiting the opt_default_collate_clause production. + ExitOpt_default_collate_clause(c *Opt_default_collate_clauseContext) + + // ExitOpt_like_path_expression is called when exiting the opt_like_path_expression production. + ExitOpt_like_path_expression(c *Opt_like_path_expressionContext) + + // ExitCreate_row_access_policy_statement is called when exiting the create_row_access_policy_statement production. + ExitCreate_row_access_policy_statement(c *Create_row_access_policy_statementContext) + + // ExitFilter_using_clause is called when exiting the filter_using_clause production. + ExitFilter_using_clause(c *Filter_using_clauseContext) + + // ExitCreate_row_access_policy_grant_to_clause is called when exiting the create_row_access_policy_grant_to_clause production. + ExitCreate_row_access_policy_grant_to_clause(c *Create_row_access_policy_grant_to_clauseContext) + + // ExitCreate_privilege_restriction_statement is called when exiting the create_privilege_restriction_statement production. + ExitCreate_privilege_restriction_statement(c *Create_privilege_restriction_statementContext) + + // ExitRestrict_to_clause is called when exiting the restrict_to_clause production. + ExitRestrict_to_clause(c *Restrict_to_clauseContext) + + // ExitPossibly_empty_grantee_list is called when exiting the possibly_empty_grantee_list production. + ExitPossibly_empty_grantee_list(c *Possibly_empty_grantee_listContext) + + // ExitCreate_index_statement is called when exiting the create_index_statement production. + ExitCreate_index_statement(c *Create_index_statementContext) + + // ExitOpt_create_index_statement_suffix is called when exiting the opt_create_index_statement_suffix production. + ExitOpt_create_index_statement_suffix(c *Opt_create_index_statement_suffixContext) + + // ExitSpanner_index_interleave_clause is called when exiting the spanner_index_interleave_clause production. + ExitSpanner_index_interleave_clause(c *Spanner_index_interleave_clauseContext) + + // ExitIndex_storing_list is called when exiting the index_storing_list production. + ExitIndex_storing_list(c *Index_storing_listContext) + + // ExitIndex_storing_expression_list is called when exiting the index_storing_expression_list production. + ExitIndex_storing_expression_list(c *Index_storing_expression_listContext) + + // ExitIndex_order_by_and_options is called when exiting the index_order_by_and_options production. + ExitIndex_order_by_and_options(c *Index_order_by_and_optionsContext) + + // ExitIndex_all_columns is called when exiting the index_all_columns production. + ExitIndex_all_columns(c *Index_all_columnsContext) + + // ExitOpt_with_column_options is called when exiting the opt_with_column_options production. + ExitOpt_with_column_options(c *Opt_with_column_optionsContext) + + // ExitAll_column_column_options is called when exiting the all_column_column_options production. + ExitAll_column_column_options(c *All_column_column_optionsContext) + + // ExitColumn_ordering_and_options_expr is called when exiting the column_ordering_and_options_expr production. + ExitColumn_ordering_and_options_expr(c *Column_ordering_and_options_exprContext) + + // ExitIndex_unnest_expression_list is called when exiting the index_unnest_expression_list production. + ExitIndex_unnest_expression_list(c *Index_unnest_expression_listContext) + + // ExitUnnest_expression_with_opt_alias_and_offset is called when exiting the unnest_expression_with_opt_alias_and_offset production. + ExitUnnest_expression_with_opt_alias_and_offset(c *Unnest_expression_with_opt_alias_and_offsetContext) + + // ExitOn_path_expression is called when exiting the on_path_expression production. + ExitOn_path_expression(c *On_path_expressionContext) + + // ExitIndex_type is called when exiting the index_type production. + ExitIndex_type(c *Index_typeContext) + + // ExitOpt_spanner_null_filtered is called when exiting the opt_spanner_null_filtered production. + ExitOpt_spanner_null_filtered(c *Opt_spanner_null_filteredContext) + + // ExitCreate_procedure_statement is called when exiting the create_procedure_statement production. + ExitCreate_procedure_statement(c *Create_procedure_statementContext) + + // ExitBegin_end_block_or_language_as_code is called when exiting the begin_end_block_or_language_as_code production. + ExitBegin_end_block_or_language_as_code(c *Begin_end_block_or_language_as_codeContext) + + // ExitBegin_end_block is called when exiting the begin_end_block production. + ExitBegin_end_block(c *Begin_end_blockContext) + + // ExitOpt_exception_handler is called when exiting the opt_exception_handler production. + ExitOpt_exception_handler(c *Opt_exception_handlerContext) + + // ExitStatement_list is called when exiting the statement_list production. + ExitStatement_list(c *Statement_listContext) + + // ExitUnterminated_non_empty_statement_list is called when exiting the unterminated_non_empty_statement_list production. + ExitUnterminated_non_empty_statement_list(c *Unterminated_non_empty_statement_listContext) + + // ExitUnterminated_statement is called when exiting the unterminated_statement production. + ExitUnterminated_statement(c *Unterminated_statementContext) + + // ExitUnterminated_script_statement is called when exiting the unterminated_script_statement production. + ExitUnterminated_script_statement(c *Unterminated_script_statementContext) + + // ExitLabel is called when exiting the label production. + ExitLabel(c *LabelContext) + + // ExitUnterminated_unlabeled_script_statement is called when exiting the unterminated_unlabeled_script_statement production. + ExitUnterminated_unlabeled_script_statement(c *Unterminated_unlabeled_script_statementContext) + + // ExitFor_in_statement is called when exiting the for_in_statement production. + ExitFor_in_statement(c *For_in_statementContext) + + // ExitRepeat_statement is called when exiting the repeat_statement production. + ExitRepeat_statement(c *Repeat_statementContext) + + // ExitUntil_clause is called when exiting the until_clause production. + ExitUntil_clause(c *Until_clauseContext) + + // ExitLoop_statement is called when exiting the loop_statement production. + ExitLoop_statement(c *Loop_statementContext) + + // ExitWhile_statement is called when exiting the while_statement production. + ExitWhile_statement(c *While_statementContext) + + // ExitRaise_statement is called when exiting the raise_statement production. + ExitRaise_statement(c *Raise_statementContext) + + // ExitReturn_statement is called when exiting the return_statement production. + ExitReturn_statement(c *Return_statementContext) + + // ExitContinue_statement is called when exiting the continue_statement production. + ExitContinue_statement(c *Continue_statementContext) + + // ExitVariable_declaration is called when exiting the variable_declaration production. + ExitVariable_declaration(c *Variable_declarationContext) + + // ExitBreak_statement is called when exiting the break_statement production. + ExitBreak_statement(c *Break_statementContext) + + // ExitCase_statement is called when exiting the case_statement production. + ExitCase_statement(c *Case_statementContext) + + // ExitWhen_then_clauses is called when exiting the when_then_clauses production. + ExitWhen_then_clauses(c *When_then_clausesContext) + + // ExitIf_statement is called when exiting the if_statement production. + ExitIf_statement(c *If_statementContext) + + // ExitElseif_clauses is called when exiting the elseif_clauses production. + ExitElseif_clauses(c *Elseif_clausesContext) + + // ExitOpt_else is called when exiting the opt_else production. + ExitOpt_else(c *Opt_elseContext) + + // ExitOpt_as_code is called when exiting the opt_as_code production. + ExitOpt_as_code(c *Opt_as_codeContext) + + // ExitOpt_external_security_clause is called when exiting the opt_external_security_clause production. + ExitOpt_external_security_clause(c *Opt_external_security_clauseContext) + + // ExitExternal_security_clause_kind is called when exiting the external_security_clause_kind production. + ExitExternal_security_clause_kind(c *External_security_clause_kindContext) + + // ExitProcedure_parameters is called when exiting the procedure_parameters production. + ExitProcedure_parameters(c *Procedure_parametersContext) + + // ExitProcedure_parameter is called when exiting the procedure_parameter production. + ExitProcedure_parameter(c *Procedure_parameterContext) + + // ExitProcedure_parameter_termination is called when exiting the procedure_parameter_termination production. + ExitProcedure_parameter_termination(c *Procedure_parameter_terminationContext) + + // ExitOpt_procedure_parameter_mode is called when exiting the opt_procedure_parameter_mode production. + ExitOpt_procedure_parameter_mode(c *Opt_procedure_parameter_modeContext) + + // ExitCreate_function_statement is called when exiting the create_function_statement production. + ExitCreate_function_statement(c *Create_function_statementContext) + + // ExitOpt_determinism_level is called when exiting the opt_determinism_level production. + ExitOpt_determinism_level(c *Opt_determinism_levelContext) + + // ExitOpt_sql_security_clause is called when exiting the opt_sql_security_clause production. + ExitOpt_sql_security_clause(c *Opt_sql_security_clauseContext) + + // ExitSql_security_clause_kind is called when exiting the sql_security_clause_kind production. + ExitSql_security_clause_kind(c *Sql_security_clause_kindContext) + + // ExitAs_sql_function_body_or_string is called when exiting the as_sql_function_body_or_string production. + ExitAs_sql_function_body_or_string(c *As_sql_function_body_or_stringContext) + + // ExitSql_function_body is called when exiting the sql_function_body production. + ExitSql_function_body(c *Sql_function_bodyContext) + + // ExitUnordered_options_body is called when exiting the unordered_options_body production. + ExitUnordered_options_body(c *Unordered_options_bodyContext) + + // ExitOpt_language_or_remote_with_connection is called when exiting the opt_language_or_remote_with_connection production. + ExitOpt_language_or_remote_with_connection(c *Opt_language_or_remote_with_connectionContext) + + // ExitLanguage is called when exiting the language production. + ExitLanguage(c *LanguageContext) + + // ExitRemote_with_connection_clause is called when exiting the remote_with_connection_clause production. + ExitRemote_with_connection_clause(c *Remote_with_connection_clauseContext) + + // ExitWith_connection_clause is called when exiting the with_connection_clause production. + ExitWith_connection_clause(c *With_connection_clauseContext) + + // ExitOpt_function_returns is called when exiting the opt_function_returns production. + ExitOpt_function_returns(c *Opt_function_returnsContext) + + // ExitOpt_returns is called when exiting the opt_returns production. + ExitOpt_returns(c *Opt_returnsContext) + + // ExitFunction_declaration is called when exiting the function_declaration production. + ExitFunction_declaration(c *Function_declarationContext) + + // ExitFunction_parameters is called when exiting the function_parameters production. + ExitFunction_parameters(c *Function_parametersContext) + + // ExitFunction_parameter is called when exiting the function_parameter production. + ExitFunction_parameter(c *Function_parameterContext) + + // ExitOpt_not_aggregate is called when exiting the opt_not_aggregate production. + ExitOpt_not_aggregate(c *Opt_not_aggregateContext) + + // ExitOpt_default_expression is called when exiting the opt_default_expression production. + ExitOpt_default_expression(c *Opt_default_expressionContext) + + // ExitType_or_tvf_schema is called when exiting the type_or_tvf_schema production. + ExitType_or_tvf_schema(c *Type_or_tvf_schemaContext) + + // ExitTvf_schema is called when exiting the tvf_schema production. + ExitTvf_schema(c *Tvf_schemaContext) + + // ExitTvf_schema_column is called when exiting the tvf_schema_column production. + ExitTvf_schema_column(c *Tvf_schema_columnContext) + + // ExitTemplated_parameter_type is called when exiting the templated_parameter_type production. + ExitTemplated_parameter_type(c *Templated_parameter_typeContext) + + // ExitTemplated_parameter_kind is called when exiting the templated_parameter_kind production. + ExitTemplated_parameter_kind(c *Templated_parameter_kindContext) + + // ExitOpt_aggregate is called when exiting the opt_aggregate production. + ExitOpt_aggregate(c *Opt_aggregateContext) + + // ExitCreate_database_statement is called when exiting the create_database_statement production. + ExitCreate_database_statement(c *Create_database_statementContext) + + // ExitCreate_connection_statement is called when exiting the create_connection_statement production. + ExitCreate_connection_statement(c *Create_connection_statementContext) + + // ExitCreate_constant_statement is called when exiting the create_constant_statement production. + ExitCreate_constant_statement(c *Create_constant_statementContext) + + // ExitOpt_or_replace is called when exiting the opt_or_replace production. + ExitOpt_or_replace(c *Opt_or_replaceContext) + + // ExitOpt_create_scope is called when exiting the opt_create_scope production. + ExitOpt_create_scope(c *Opt_create_scopeContext) + + // ExitRun_batch_statement is called when exiting the run_batch_statement production. + ExitRun_batch_statement(c *Run_batch_statementContext) + + // ExitAbort_batch_statement is called when exiting the abort_batch_statement production. + ExitAbort_batch_statement(c *Abort_batch_statementContext) + + // ExitStart_batch_statement is called when exiting the start_batch_statement production. + ExitStart_batch_statement(c *Start_batch_statementContext) + + // ExitRollback_statement is called when exiting the rollback_statement production. + ExitRollback_statement(c *Rollback_statementContext) + + // ExitCommit_statement is called when exiting the commit_statement production. + ExitCommit_statement(c *Commit_statementContext) + + // ExitSet_statement is called when exiting the set_statement production. + ExitSet_statement(c *Set_statementContext) + + // ExitIdentifier_list is called when exiting the identifier_list production. + ExitIdentifier_list(c *Identifier_listContext) + + // ExitBegin_statement is called when exiting the begin_statement production. + ExitBegin_statement(c *Begin_statementContext) + + // ExitBegin_transaction_keywords is called when exiting the begin_transaction_keywords production. + ExitBegin_transaction_keywords(c *Begin_transaction_keywordsContext) + + // ExitTransaction_mode_list is called when exiting the transaction_mode_list production. + ExitTransaction_mode_list(c *Transaction_mode_listContext) + + // ExitTransaction_mode is called when exiting the transaction_mode production. + ExitTransaction_mode(c *Transaction_modeContext) + + // ExitTruncate_statement is called when exiting the truncate_statement production. + ExitTruncate_statement(c *Truncate_statementContext) + + // ExitMerge_statement is called when exiting the merge_statement production. + ExitMerge_statement(c *Merge_statementContext) + + // ExitMerge_source is called when exiting the merge_source production. + ExitMerge_source(c *Merge_sourceContext) + + // ExitMerge_when_clause is called when exiting the merge_when_clause production. + ExitMerge_when_clause(c *Merge_when_clauseContext) + + // ExitMerge_action is called when exiting the merge_action production. + ExitMerge_action(c *Merge_actionContext) + + // ExitMerge_insert_value_list_or_source_row is called when exiting the merge_insert_value_list_or_source_row production. + ExitMerge_insert_value_list_or_source_row(c *Merge_insert_value_list_or_source_rowContext) + + // ExitBy_target is called when exiting the by_target production. + ExitBy_target(c *By_targetContext) + + // ExitOpt_and_expression is called when exiting the opt_and_expression production. + ExitOpt_and_expression(c *Opt_and_expressionContext) + + // ExitStatement_level_hint is called when exiting the statement_level_hint production. + ExitStatement_level_hint(c *Statement_level_hintContext) + + // ExitQuery_statement is called when exiting the query_statement production. + ExitQuery_statement(c *Query_statementContext) + + // ExitDml_statement is called when exiting the dml_statement production. + ExitDml_statement(c *Dml_statementContext) + + // ExitUpdate_statement is called when exiting the update_statement production. + ExitUpdate_statement(c *Update_statementContext) + + // ExitDelete_statement is called when exiting the delete_statement production. + ExitDelete_statement(c *Delete_statementContext) + + // ExitInsert_statement is called when exiting the insert_statement production. + ExitInsert_statement(c *Insert_statementContext) + + // ExitOn_conflict_clause is called when exiting the on_conflict_clause production. + ExitOn_conflict_clause(c *On_conflict_clauseContext) + + // ExitOpt_where_expression is called when exiting the opt_where_expression production. + ExitOpt_where_expression(c *Opt_where_expressionContext) + + // ExitOpt_conflict_target is called when exiting the opt_conflict_target production. + ExitOpt_conflict_target(c *Opt_conflict_targetContext) + + // ExitUpdate_item_list is called when exiting the update_item_list production. + ExitUpdate_item_list(c *Update_item_listContext) + + // ExitUpdate_item is called when exiting the update_item production. + ExitUpdate_item(c *Update_itemContext) + + // ExitUpdate_set_value is called when exiting the update_set_value production. + ExitUpdate_set_value(c *Update_set_valueContext) + + // ExitNested_dml_statement is called when exiting the nested_dml_statement production. + ExitNested_dml_statement(c *Nested_dml_statementContext) + + // ExitInsert_values_list_or_table_clause is called when exiting the insert_values_list_or_table_clause production. + ExitInsert_values_list_or_table_clause(c *Insert_values_list_or_table_clauseContext) + + // ExitTable_clause_unreversed is called when exiting the table_clause_unreversed production. + ExitTable_clause_unreversed(c *Table_clause_unreversedContext) + + // ExitTable_clause_no_keyword is called when exiting the table_clause_no_keyword production. + ExitTable_clause_no_keyword(c *Table_clause_no_keywordContext) + + // ExitOpt_returning_clause is called when exiting the opt_returning_clause production. + ExitOpt_returning_clause(c *Opt_returning_clauseContext) + + // ExitOpt_assert_rows_modified is called when exiting the opt_assert_rows_modified production. + ExitOpt_assert_rows_modified(c *Opt_assert_rows_modifiedContext) + + // ExitInsert_values_or_query is called when exiting the insert_values_or_query production. + ExitInsert_values_or_query(c *Insert_values_or_queryContext) + + // ExitInsert_values_list is called when exiting the insert_values_list production. + ExitInsert_values_list(c *Insert_values_listContext) + + // ExitInsert_values_row is called when exiting the insert_values_row production. + ExitInsert_values_row(c *Insert_values_rowContext) + + // ExitExpression_or_default is called when exiting the expression_or_default production. + ExitExpression_or_default(c *Expression_or_defaultContext) + + // ExitInsert_statement_prefix is called when exiting the insert_statement_prefix production. + ExitInsert_statement_prefix(c *Insert_statement_prefixContext) + + // ExitMaybe_dashed_generalized_path_expression is called when exiting the maybe_dashed_generalized_path_expression production. + ExitMaybe_dashed_generalized_path_expression(c *Maybe_dashed_generalized_path_expressionContext) + + // ExitOpt_into is called when exiting the opt_into production. + ExitOpt_into(c *Opt_intoContext) + + // ExitOpt_or_ignore_replace_update is called when exiting the opt_or_ignore_replace_update production. + ExitOpt_or_ignore_replace_update(c *Opt_or_ignore_replace_updateContext) + + // ExitAlter_statement is called when exiting the alter_statement production. + ExitAlter_statement(c *Alter_statementContext) + + // ExitAnalyze_statement is called when exiting the analyze_statement production. + ExitAnalyze_statement(c *Analyze_statementContext) + + // ExitAssert_statement is called when exiting the assert_statement production. + ExitAssert_statement(c *Assert_statementContext) + + // ExitAux_load_data_statement is called when exiting the aux_load_data_statement production. + ExitAux_load_data_statement(c *Aux_load_data_statementContext) + + // ExitClone_data_statement is called when exiting the clone_data_statement production. + ExitClone_data_statement(c *Clone_data_statementContext) + + // ExitClone_data_source_list is called when exiting the clone_data_source_list production. + ExitClone_data_source_list(c *Clone_data_source_listContext) + + // ExitClone_data_source is called when exiting the clone_data_source production. + ExitClone_data_source(c *Clone_data_sourceContext) + + // ExitOpt_external_table_with_clauses is called when exiting the opt_external_table_with_clauses production. + ExitOpt_external_table_with_clauses(c *Opt_external_table_with_clausesContext) + + // ExitWith_partition_columns_clause is called when exiting the with_partition_columns_clause production. + ExitWith_partition_columns_clause(c *With_partition_columns_clauseContext) + + // ExitAux_load_data_from_files_options_list is called when exiting the aux_load_data_from_files_options_list production. + ExitAux_load_data_from_files_options_list(c *Aux_load_data_from_files_options_listContext) + + // ExitCluster_by_clause_prefix_no_hint is called when exiting the cluster_by_clause_prefix_no_hint production. + ExitCluster_by_clause_prefix_no_hint(c *Cluster_by_clause_prefix_no_hintContext) + + // ExitLoad_data_partitions_clause is called when exiting the load_data_partitions_clause production. + ExitLoad_data_partitions_clause(c *Load_data_partitions_clauseContext) + + // ExitMaybe_dashed_path_expression_with_scope is called when exiting the maybe_dashed_path_expression_with_scope production. + ExitMaybe_dashed_path_expression_with_scope(c *Maybe_dashed_path_expression_with_scopeContext) + + // ExitTable_element_list is called when exiting the table_element_list production. + ExitTable_element_list(c *Table_element_listContext) + + // ExitTable_element is called when exiting the table_element production. + ExitTable_element(c *Table_elementContext) + + // ExitTable_constraint_definition is called when exiting the table_constraint_definition production. + ExitTable_constraint_definition(c *Table_constraint_definitionContext) + + // ExitAppend_or_overwrite is called when exiting the append_or_overwrite production. + ExitAppend_or_overwrite(c *Append_or_overwriteContext) + + // ExitOpt_description is called when exiting the opt_description production. + ExitOpt_description(c *Opt_descriptionContext) + + // ExitTable_and_column_info_list is called when exiting the table_and_column_info_list production. + ExitTable_and_column_info_list(c *Table_and_column_info_listContext) + + // ExitTable_and_column_info is called when exiting the table_and_column_info production. + ExitTable_and_column_info(c *Table_and_column_infoContext) + + // ExitRow_access_policy_alter_action_list is called when exiting the row_access_policy_alter_action_list production. + ExitRow_access_policy_alter_action_list(c *Row_access_policy_alter_action_listContext) + + // ExitRow_access_policy_alter_action is called when exiting the row_access_policy_alter_action production. + ExitRow_access_policy_alter_action(c *Row_access_policy_alter_actionContext) + + // ExitGrant_to_clause is called when exiting the grant_to_clause production. + ExitGrant_to_clause(c *Grant_to_clauseContext) + + // ExitGrantee_list is called when exiting the grantee_list production. + ExitGrantee_list(c *Grantee_listContext) + + // ExitPrivilege_list is called when exiting the privilege_list production. + ExitPrivilege_list(c *Privilege_listContext) + + // ExitPrivilege is called when exiting the privilege production. + ExitPrivilege(c *PrivilegeContext) + + // ExitPath_expression_list_with_parens is called when exiting the path_expression_list_with_parens production. + ExitPath_expression_list_with_parens(c *Path_expression_list_with_parensContext) + + // ExitPrivilege_name is called when exiting the privilege_name production. + ExitPrivilege_name(c *Privilege_nameContext) + + // ExitGeneric_entity_type is called when exiting the generic_entity_type production. + ExitGeneric_entity_type(c *Generic_entity_typeContext) + + // ExitGeneric_entity_type_unchecked is called when exiting the generic_entity_type_unchecked production. + ExitGeneric_entity_type_unchecked(c *Generic_entity_type_uncheckedContext) + + // ExitSchema_object_kind is called when exiting the schema_object_kind production. + ExitSchema_object_kind(c *Schema_object_kindContext) + + // ExitAlter_action_list is called when exiting the alter_action_list production. + ExitAlter_action_list(c *Alter_action_listContext) + + // ExitAlter_action is called when exiting the alter_action production. + ExitAlter_action(c *Alter_actionContext) + + // ExitSpanner_set_on_delete_action is called when exiting the spanner_set_on_delete_action production. + ExitSpanner_set_on_delete_action(c *Spanner_set_on_delete_actionContext) + + // ExitSpanner_alter_column_action is called when exiting the spanner_alter_column_action production. + ExitSpanner_alter_column_action(c *Spanner_alter_column_actionContext) + + // ExitSpanner_generated_or_default is called when exiting the spanner_generated_or_default production. + ExitSpanner_generated_or_default(c *Spanner_generated_or_defaultContext) + + // ExitGeneric_sub_entity_type is called when exiting the generic_sub_entity_type production. + ExitGeneric_sub_entity_type(c *Generic_sub_entity_typeContext) + + // ExitSub_entity_type_identifier is called when exiting the sub_entity_type_identifier production. + ExitSub_entity_type_identifier(c *Sub_entity_type_identifierContext) + + // ExitFill_using_expression is called when exiting the fill_using_expression production. + ExitFill_using_expression(c *Fill_using_expressionContext) + + // ExitColumn_position is called when exiting the column_position production. + ExitColumn_position(c *Column_positionContext) + + // ExitTable_column_definition is called when exiting the table_column_definition production. + ExitTable_column_definition(c *Table_column_definitionContext) + + // ExitColumn_attributes is called when exiting the column_attributes production. + ExitColumn_attributes(c *Column_attributesContext) + + // ExitColumn_attribute is called when exiting the column_attribute production. + ExitColumn_attribute(c *Column_attributeContext) + + // ExitPrimary_key_column_attribute is called when exiting the primary_key_column_attribute production. + ExitPrimary_key_column_attribute(c *Primary_key_column_attributeContext) + + // ExitForeign_key_column_attribute is called when exiting the foreign_key_column_attribute production. + ExitForeign_key_column_attribute(c *Foreign_key_column_attributeContext) + + // ExitHidden_column_attribute is called when exiting the hidden_column_attribute production. + ExitHidden_column_attribute(c *Hidden_column_attributeContext) + + // ExitOpt_constraint_identity is called when exiting the opt_constraint_identity production. + ExitOpt_constraint_identity(c *Opt_constraint_identityContext) + + // ExitTable_column_schema is called when exiting the table_column_schema production. + ExitTable_column_schema(c *Table_column_schemaContext) + + // ExitOpt_column_info is called when exiting the opt_column_info production. + ExitOpt_column_info(c *Opt_column_infoContext) + + // ExitInvalid_generated_column is called when exiting the invalid_generated_column production. + ExitInvalid_generated_column(c *Invalid_generated_columnContext) + + // ExitInvalid_default_column is called when exiting the invalid_default_column production. + ExitInvalid_default_column(c *Invalid_default_columnContext) + + // ExitDefault_column_info is called when exiting the default_column_info production. + ExitDefault_column_info(c *Default_column_infoContext) + + // ExitGenerated_column_info is called when exiting the generated_column_info production. + ExitGenerated_column_info(c *Generated_column_infoContext) + + // ExitIdentity_column_info is called when exiting the identity_column_info production. + ExitIdentity_column_info(c *Identity_column_infoContext) + + // ExitOpt_start_with is called when exiting the opt_start_with production. + ExitOpt_start_with(c *Opt_start_withContext) + + // ExitOpt_increment_by is called when exiting the opt_increment_by production. + ExitOpt_increment_by(c *Opt_increment_byContext) + + // ExitOpt_maxvalue is called when exiting the opt_maxvalue production. + ExitOpt_maxvalue(c *Opt_maxvalueContext) + + // ExitOpt_minvalue is called when exiting the opt_minvalue production. + ExitOpt_minvalue(c *Opt_minvalueContext) + + // ExitOpt_cycle is called when exiting the opt_cycle production. + ExitOpt_cycle(c *Opt_cycleContext) + + // ExitSigned_numeric_literal is called when exiting the signed_numeric_literal production. + ExitSigned_numeric_literal(c *Signed_numeric_literalContext) + + // ExitStored_mode is called when exiting the stored_mode production. + ExitStored_mode(c *Stored_modeContext) + + // ExitGenerated_mode is called when exiting the generated_mode production. + ExitGenerated_mode(c *Generated_modeContext) + + // ExitColumn_schema_inner is called when exiting the column_schema_inner production. + ExitColumn_schema_inner(c *Column_schema_innerContext) + + // ExitRaw_column_schema_inner is called when exiting the raw_column_schema_inner production. + ExitRaw_column_schema_inner(c *Raw_column_schema_innerContext) + + // ExitRange_column_schema_inner is called when exiting the range_column_schema_inner production. + ExitRange_column_schema_inner(c *Range_column_schema_innerContext) + + // ExitStruct_column_schema_inner is called when exiting the struct_column_schema_inner production. + ExitStruct_column_schema_inner(c *Struct_column_schema_innerContext) + + // ExitStruct_column_field is called when exiting the struct_column_field production. + ExitStruct_column_field(c *Struct_column_fieldContext) + + // ExitSimple_column_schema_inner is called when exiting the simple_column_schema_inner production. + ExitSimple_column_schema_inner(c *Simple_column_schema_innerContext) + + // ExitArray_column_schema_inner is called when exiting the array_column_schema_inner production. + ExitArray_column_schema_inner(c *Array_column_schema_innerContext) + + // ExitField_schema is called when exiting the field_schema production. + ExitField_schema(c *Field_schemaContext) + + // ExitOpt_field_attributes is called when exiting the opt_field_attributes production. + ExitOpt_field_attributes(c *Opt_field_attributesContext) + + // ExitNot_null_column_attribute is called when exiting the not_null_column_attribute production. + ExitNot_null_column_attribute(c *Not_null_column_attributeContext) + + // ExitPrimary_key_or_table_constraint_spec is called when exiting the primary_key_or_table_constraint_spec production. + ExitPrimary_key_or_table_constraint_spec(c *Primary_key_or_table_constraint_specContext) + + // ExitOpt_if_not_exists is called when exiting the opt_if_not_exists production. + ExitOpt_if_not_exists(c *Opt_if_not_existsContext) + + // ExitPrimary_key_spec is called when exiting the primary_key_spec production. + ExitPrimary_key_spec(c *Primary_key_specContext) + + // ExitPrimary_key_element_list is called when exiting the primary_key_element_list production. + ExitPrimary_key_element_list(c *Primary_key_element_listContext) + + // ExitPrimary_key_element is called when exiting the primary_key_element production. + ExitPrimary_key_element(c *Primary_key_elementContext) + + // ExitTable_constraint_spec is called when exiting the table_constraint_spec production. + ExitTable_constraint_spec(c *Table_constraint_specContext) + + // ExitForeign_key_reference is called when exiting the foreign_key_reference production. + ExitForeign_key_reference(c *Foreign_key_referenceContext) + + // ExitOpt_foreign_key_action is called when exiting the opt_foreign_key_action production. + ExitOpt_foreign_key_action(c *Opt_foreign_key_actionContext) + + // ExitForeign_key_on_update is called when exiting the foreign_key_on_update production. + ExitForeign_key_on_update(c *Foreign_key_on_updateContext) + + // ExitForeign_key_on_delete is called when exiting the foreign_key_on_delete production. + ExitForeign_key_on_delete(c *Foreign_key_on_deleteContext) + + // ExitForeign_key_action is called when exiting the foreign_key_action production. + ExitForeign_key_action(c *Foreign_key_actionContext) + + // ExitOpt_foreign_key_match is called when exiting the opt_foreign_key_match production. + ExitOpt_foreign_key_match(c *Opt_foreign_key_matchContext) + + // ExitForeign_key_match_mode is called when exiting the foreign_key_match_mode production. + ExitForeign_key_match_mode(c *Foreign_key_match_modeContext) + + // ExitColumn_list is called when exiting the column_list production. + ExitColumn_list(c *Column_listContext) + + // ExitOpt_options_list is called when exiting the opt_options_list production. + ExitOpt_options_list(c *Opt_options_listContext) + + // ExitConstraint_enforcement is called when exiting the constraint_enforcement production. + ExitConstraint_enforcement(c *Constraint_enforcementContext) + + // ExitGeneric_entity_body is called when exiting the generic_entity_body production. + ExitGeneric_entity_body(c *Generic_entity_bodyContext) + + // ExitOpt_if_exists is called when exiting the opt_if_exists production. + ExitOpt_if_exists(c *Opt_if_existsContext) + + // ExitTable_or_table_function is called when exiting the table_or_table_function production. + ExitTable_or_table_function(c *Table_or_table_functionContext) + + // ExitQuery is called when exiting the query production. + ExitQuery(c *QueryContext) + + // ExitQuery_without_pipe_operators is called when exiting the query_without_pipe_operators production. + ExitQuery_without_pipe_operators(c *Query_without_pipe_operatorsContext) + + // ExitBad_keyword_after_from_query is called when exiting the bad_keyword_after_from_query production. + ExitBad_keyword_after_from_query(c *Bad_keyword_after_from_queryContext) + + // ExitBad_keyword_after_from_query_allows_parens is called when exiting the bad_keyword_after_from_query_allows_parens production. + ExitBad_keyword_after_from_query_allows_parens(c *Bad_keyword_after_from_query_allows_parensContext) + + // ExitWith_clause_with_trailing_comma is called when exiting the with_clause_with_trailing_comma production. + ExitWith_clause_with_trailing_comma(c *With_clause_with_trailing_commaContext) + + // ExitSelect_or_from_keyword is called when exiting the select_or_from_keyword production. + ExitSelect_or_from_keyword(c *Select_or_from_keywordContext) + + // ExitQuery_primary_or_set_operation is called when exiting the query_primary_or_set_operation production. + ExitQuery_primary_or_set_operation(c *Query_primary_or_set_operationContext) + + // ExitQuery_set_operation is called when exiting the query_set_operation production. + ExitQuery_set_operation(c *Query_set_operationContext) + + // ExitQuery_set_operation_prefix is called when exiting the query_set_operation_prefix production. + ExitQuery_set_operation_prefix(c *Query_set_operation_prefixContext) + + // ExitQuery_set_operation_item is called when exiting the query_set_operation_item production. + ExitQuery_set_operation_item(c *Query_set_operation_itemContext) + + // ExitQuery_primary is called when exiting the query_primary production. + ExitQuery_primary(c *Query_primaryContext) + + // ExitSet_operation_metadata is called when exiting the set_operation_metadata production. + ExitSet_operation_metadata(c *Set_operation_metadataContext) + + // ExitOpt_column_match_suffix is called when exiting the opt_column_match_suffix production. + ExitOpt_column_match_suffix(c *Opt_column_match_suffixContext) + + // ExitOpt_strict is called when exiting the opt_strict production. + ExitOpt_strict(c *Opt_strictContext) + + // ExitAll_or_distinct is called when exiting the all_or_distinct production. + ExitAll_or_distinct(c *All_or_distinctContext) + + // ExitQuery_set_operation_type is called when exiting the query_set_operation_type production. + ExitQuery_set_operation_type(c *Query_set_operation_typeContext) + + // ExitOpt_corresponding_outer_mode is called when exiting the opt_corresponding_outer_mode production. + ExitOpt_corresponding_outer_mode(c *Opt_corresponding_outer_modeContext) + + // ExitOpt_outer is called when exiting the opt_outer production. + ExitOpt_outer(c *Opt_outerContext) + + // ExitWith_clause is called when exiting the with_clause production. + ExitWith_clause(c *With_clauseContext) + + // ExitAliased_query is called when exiting the aliased_query production. + ExitAliased_query(c *Aliased_queryContext) + + // ExitOpt_aliased_query_modifiers is called when exiting the opt_aliased_query_modifiers production. + ExitOpt_aliased_query_modifiers(c *Opt_aliased_query_modifiersContext) + + // ExitRecursion_depth_modifier is called when exiting the recursion_depth_modifier production. + ExitRecursion_depth_modifier(c *Recursion_depth_modifierContext) + + // ExitPossibly_unbounded_int_literal_or_parameter is called when exiting the possibly_unbounded_int_literal_or_parameter production. + ExitPossibly_unbounded_int_literal_or_parameter(c *Possibly_unbounded_int_literal_or_parameterContext) + + // ExitInt_literal_or_parameter is called when exiting the int_literal_or_parameter production. + ExitInt_literal_or_parameter(c *Int_literal_or_parameterContext) + + // ExitOrder_by_clause is called when exiting the order_by_clause production. + ExitOrder_by_clause(c *Order_by_clauseContext) + + // ExitOrder_by_clause_prefix is called when exiting the order_by_clause_prefix production. + ExitOrder_by_clause_prefix(c *Order_by_clause_prefixContext) + + // ExitOrdering_expression is called when exiting the ordering_expression production. + ExitOrdering_expression(c *Ordering_expressionContext) + + // ExitSelect is called when exiting the select production. + ExitSelect(c *SelectContext) + + // ExitOpt_clauses_following_from is called when exiting the opt_clauses_following_from production. + ExitOpt_clauses_following_from(c *Opt_clauses_following_fromContext) + + // ExitOpt_clauses_following_where is called when exiting the opt_clauses_following_where production. + ExitOpt_clauses_following_where(c *Opt_clauses_following_whereContext) + + // ExitOpt_clauses_following_group_by is called when exiting the opt_clauses_following_group_by production. + ExitOpt_clauses_following_group_by(c *Opt_clauses_following_group_byContext) + + // ExitWindow_clause is called when exiting the window_clause production. + ExitWindow_clause(c *Window_clauseContext) + + // ExitWindow_clause_prefix is called when exiting the window_clause_prefix production. + ExitWindow_clause_prefix(c *Window_clause_prefixContext) + + // ExitWindow_definition is called when exiting the window_definition production. + ExitWindow_definition(c *Window_definitionContext) + + // ExitWhere_clause is called when exiting the where_clause production. + ExitWhere_clause(c *Where_clauseContext) + + // ExitHaving_clause is called when exiting the having_clause production. + ExitHaving_clause(c *Having_clauseContext) + + // ExitGroup_by_clause is called when exiting the group_by_clause production. + ExitGroup_by_clause(c *Group_by_clauseContext) + + // ExitGroup_by_all is called when exiting the group_by_all production. + ExitGroup_by_all(c *Group_by_allContext) + + // ExitSelect_clause is called when exiting the select_clause production. + ExitSelect_clause(c *Select_clauseContext) + + // ExitOpt_select_as_clause is called when exiting the opt_select_as_clause production. + ExitOpt_select_as_clause(c *Opt_select_as_clauseContext) + + // ExitOpt_select_with is called when exiting the opt_select_with production. + ExitOpt_select_with(c *Opt_select_withContext) + + // ExitFrom_clause is called when exiting the from_clause production. + ExitFrom_clause(c *From_clauseContext) + + // ExitFrom_clause_contents is called when exiting the from_clause_contents production. + ExitFrom_clause_contents(c *From_clause_contentsContext) + + // ExitFrom_clause_contents_suffix is called when exiting the from_clause_contents_suffix production. + ExitFrom_clause_contents_suffix(c *From_clause_contents_suffixContext) + + // ExitTable_primary is called when exiting the table_primary production. + ExitTable_primary(c *Table_primaryContext) + + // ExitTvf_with_suffixes is called when exiting the tvf_with_suffixes production. + ExitTvf_with_suffixes(c *Tvf_with_suffixesContext) + + // ExitPivot_or_unpivot_clause_and_aliases is called when exiting the pivot_or_unpivot_clause_and_aliases production. + ExitPivot_or_unpivot_clause_and_aliases(c *Pivot_or_unpivot_clause_and_aliasesContext) + + // ExitAs_alias is called when exiting the as_alias production. + ExitAs_alias(c *As_aliasContext) + + // ExitSample_clause is called when exiting the sample_clause production. + ExitSample_clause(c *Sample_clauseContext) + + // ExitOpt_sample_clause_suffix is called when exiting the opt_sample_clause_suffix production. + ExitOpt_sample_clause_suffix(c *Opt_sample_clause_suffixContext) + + // ExitRepeatable_clause is called when exiting the repeatable_clause production. + ExitRepeatable_clause(c *Repeatable_clauseContext) + + // ExitPossibly_cast_int_literal_or_parameter is called when exiting the possibly_cast_int_literal_or_parameter production. + ExitPossibly_cast_int_literal_or_parameter(c *Possibly_cast_int_literal_or_parameterContext) + + // ExitCast_int_literal_or_parameter is called when exiting the cast_int_literal_or_parameter production. + ExitCast_int_literal_or_parameter(c *Cast_int_literal_or_parameterContext) + + // ExitSample_size is called when exiting the sample_size production. + ExitSample_size(c *Sample_sizeContext) + + // ExitSample_size_value is called when exiting the sample_size_value production. + ExitSample_size_value(c *Sample_size_valueContext) + + // ExitSample_size_unit is called when exiting the sample_size_unit production. + ExitSample_size_unit(c *Sample_size_unitContext) + + // ExitPartition_by_clause_prefix_no_hint is called when exiting the partition_by_clause_prefix_no_hint production. + ExitPartition_by_clause_prefix_no_hint(c *Partition_by_clause_prefix_no_hintContext) + + // ExitMatch_recognize_clause is called when exiting the match_recognize_clause production. + ExitMatch_recognize_clause(c *Match_recognize_clauseContext) + + // ExitRow_pattern_expr is called when exiting the row_pattern_expr production. + ExitRow_pattern_expr(c *Row_pattern_exprContext) + + // ExitRow_pattern_concatenation is called when exiting the row_pattern_concatenation production. + ExitRow_pattern_concatenation(c *Row_pattern_concatenationContext) + + // ExitRow_pattern_factor is called when exiting the row_pattern_factor production. + ExitRow_pattern_factor(c *Row_pattern_factorContext) + + // ExitSelect_list_prefix_with_as_aliases is called when exiting the select_list_prefix_with_as_aliases production. + ExitSelect_list_prefix_with_as_aliases(c *Select_list_prefix_with_as_aliasesContext) + + // ExitSelect_column_expr_with_as_alias is called when exiting the select_column_expr_with_as_alias production. + ExitSelect_column_expr_with_as_alias(c *Select_column_expr_with_as_aliasContext) + + // ExitTable_subquery is called when exiting the table_subquery production. + ExitTable_subquery(c *Table_subqueryContext) + + // ExitJoin is called when exiting the join production. + ExitJoin(c *JoinContext) + + // ExitJoin_item is called when exiting the join_item production. + ExitJoin_item(c *Join_itemContext) + + // ExitOn_or_using_clause_list is called when exiting the on_or_using_clause_list production. + ExitOn_or_using_clause_list(c *On_or_using_clause_listContext) + + // ExitOn_or_using_clause is called when exiting the on_or_using_clause production. + ExitOn_or_using_clause(c *On_or_using_clauseContext) + + // ExitUsing_clause is called when exiting the using_clause production. + ExitUsing_clause(c *Using_clauseContext) + + // ExitJoin_hint is called when exiting the join_hint production. + ExitJoin_hint(c *Join_hintContext) + + // ExitTable_path_expression is called when exiting the table_path_expression production. + ExitTable_path_expression(c *Table_path_expressionContext) + + // ExitOpt_at_system_time is called when exiting the opt_at_system_time production. + ExitOpt_at_system_time(c *Opt_at_system_timeContext) + + // ExitOpt_with_offset_and_alias is called when exiting the opt_with_offset_and_alias production. + ExitOpt_with_offset_and_alias(c *Opt_with_offset_and_aliasContext) + + // ExitOpt_pivot_or_unpivot_clause_and_alias is called when exiting the opt_pivot_or_unpivot_clause_and_alias production. + ExitOpt_pivot_or_unpivot_clause_and_alias(c *Opt_pivot_or_unpivot_clause_and_aliasContext) + + // ExitTable_path_expression_base is called when exiting the table_path_expression_base production. + ExitTable_path_expression_base(c *Table_path_expression_baseContext) + + // ExitMaybe_slashed_or_dashed_path_expression is called when exiting the maybe_slashed_or_dashed_path_expression production. + ExitMaybe_slashed_or_dashed_path_expression(c *Maybe_slashed_or_dashed_path_expressionContext) + + // ExitMaybe_dashed_path_expression is called when exiting the maybe_dashed_path_expression production. + ExitMaybe_dashed_path_expression(c *Maybe_dashed_path_expressionContext) + + // ExitDashed_path_expression is called when exiting the dashed_path_expression production. + ExitDashed_path_expression(c *Dashed_path_expressionContext) + + // ExitDashed_identifier is called when exiting the dashed_identifier production. + ExitDashed_identifier(c *Dashed_identifierContext) + + // ExitSlashed_identifier is called when exiting the slashed_identifier production. + ExitSlashed_identifier(c *Slashed_identifierContext) + + // ExitIdentifier_or_integer is called when exiting the identifier_or_integer production. + ExitIdentifier_or_integer(c *Identifier_or_integerContext) + + // ExitSlashed_identifier_separator is called when exiting the slashed_identifier_separator production. + ExitSlashed_identifier_separator(c *Slashed_identifier_separatorContext) + + // ExitSlashed_path_expression is called when exiting the slashed_path_expression production. + ExitSlashed_path_expression(c *Slashed_path_expressionContext) + + // ExitUnnest_expression is called when exiting the unnest_expression production. + ExitUnnest_expression(c *Unnest_expressionContext) + + // ExitUnnest_expression_prefix is called when exiting the unnest_expression_prefix production. + ExitUnnest_expression_prefix(c *Unnest_expression_prefixContext) + + // ExitOpt_array_zip_mode is called when exiting the opt_array_zip_mode production. + ExitOpt_array_zip_mode(c *Opt_array_zip_modeContext) + + // ExitExpression_with_opt_alias is called when exiting the expression_with_opt_alias production. + ExitExpression_with_opt_alias(c *Expression_with_opt_aliasContext) + + // ExitTvf_prefix is called when exiting the tvf_prefix production. + ExitTvf_prefix(c *Tvf_prefixContext) + + // ExitTvf_argument is called when exiting the tvf_argument production. + ExitTvf_argument(c *Tvf_argumentContext) + + // ExitConnection_clause is called when exiting the connection_clause production. + ExitConnection_clause(c *Connection_clauseContext) + + // ExitPath_expression_or_default is called when exiting the path_expression_or_default production. + ExitPath_expression_or_default(c *Path_expression_or_defaultContext) + + // ExitDescriptor_argument is called when exiting the descriptor_argument production. + ExitDescriptor_argument(c *Descriptor_argumentContext) + + // ExitDescriptor_column_list is called when exiting the descriptor_column_list production. + ExitDescriptor_column_list(c *Descriptor_column_listContext) + + // ExitDescriptor_column is called when exiting the descriptor_column production. + ExitDescriptor_column(c *Descriptor_columnContext) + + // ExitTable_clause is called when exiting the table_clause production. + ExitTable_clause(c *Table_clauseContext) + + // ExitModel_clause is called when exiting the model_clause production. + ExitModel_clause(c *Model_clauseContext) + + // ExitQualify_clause_nonreserved is called when exiting the qualify_clause_nonreserved production. + ExitQualify_clause_nonreserved(c *Qualify_clause_nonreservedContext) + + // ExitUnpivot_clause is called when exiting the unpivot_clause production. + ExitUnpivot_clause(c *Unpivot_clauseContext) + + // ExitUnpivot_in_item_list is called when exiting the unpivot_in_item_list production. + ExitUnpivot_in_item_list(c *Unpivot_in_item_listContext) + + // ExitUnpivot_in_item_list_prefix is called when exiting the unpivot_in_item_list_prefix production. + ExitUnpivot_in_item_list_prefix(c *Unpivot_in_item_list_prefixContext) + + // ExitUnpivot_in_item is called when exiting the unpivot_in_item production. + ExitUnpivot_in_item(c *Unpivot_in_itemContext) + + // ExitOpt_as_string_or_integer is called when exiting the opt_as_string_or_integer production. + ExitOpt_as_string_or_integer(c *Opt_as_string_or_integerContext) + + // ExitPath_expression_list_with_opt_parens is called when exiting the path_expression_list_with_opt_parens production. + ExitPath_expression_list_with_opt_parens(c *Path_expression_list_with_opt_parensContext) + + // ExitPath_expression_list is called when exiting the path_expression_list production. + ExitPath_expression_list(c *Path_expression_listContext) + + // ExitUnpivot_nulls_filter is called when exiting the unpivot_nulls_filter production. + ExitUnpivot_nulls_filter(c *Unpivot_nulls_filterContext) + + // ExitPivot_clause is called when exiting the pivot_clause production. + ExitPivot_clause(c *Pivot_clauseContext) + + // ExitPivot_expression_list is called when exiting the pivot_expression_list production. + ExitPivot_expression_list(c *Pivot_expression_listContext) + + // ExitPivot_expression is called when exiting the pivot_expression production. + ExitPivot_expression(c *Pivot_expressionContext) + + // ExitPivot_value_list is called when exiting the pivot_value_list production. + ExitPivot_value_list(c *Pivot_value_listContext) + + // ExitPivot_value is called when exiting the pivot_value production. + ExitPivot_value(c *Pivot_valueContext) + + // ExitTvf_prefix_no_args is called when exiting the tvf_prefix_no_args production. + ExitTvf_prefix_no_args(c *Tvf_prefix_no_argsContext) + + // ExitJoin_type is called when exiting the join_type production. + ExitJoin_type(c *Join_typeContext) + + // ExitOpt_natural is called when exiting the opt_natural production. + ExitOpt_natural(c *Opt_naturalContext) + + // ExitOn_clause is called when exiting the on_clause production. + ExitOn_clause(c *On_clauseContext) + + // ExitSelect_list is called when exiting the select_list production. + ExitSelect_list(c *Select_listContext) + + // ExitSelect_list_item is called when exiting the select_list_item production. + ExitSelect_list_item(c *Select_list_itemContext) + + // ExitSelect_column_star is called when exiting the select_column_star production. + ExitSelect_column_star(c *Select_column_starContext) + + // ExitSelect_column_expr is called when exiting the select_column_expr production. + ExitSelect_column_expr(c *Select_column_exprContext) + + // ExitSelect_column_dot_star is called when exiting the select_column_dot_star production. + ExitSelect_column_dot_star(c *Select_column_dot_starContext) + + // ExitStar_modifiers is called when exiting the star_modifiers production. + ExitStar_modifiers(c *Star_modifiersContext) + + // ExitStar_except_list is called when exiting the star_except_list production. + ExitStar_except_list(c *Star_except_listContext) + + // ExitStar_replace_list is called when exiting the star_replace_list production. + ExitStar_replace_list(c *Star_replace_listContext) + + // ExitStar_replace_item is called when exiting the star_replace_item production. + ExitStar_replace_item(c *Star_replace_itemContext) + + // ExitExpression is called when exiting the expression production. + ExitExpression(c *ExpressionContext) + + // ExitExpression_higher_prec_than_and is called when exiting the expression_higher_prec_than_and production. + ExitExpression_higher_prec_than_and(c *Expression_higher_prec_than_andContext) + + // ExitExpression_maybe_parenthesized_not_a_query is called when exiting the expression_maybe_parenthesized_not_a_query production. + ExitExpression_maybe_parenthesized_not_a_query(c *Expression_maybe_parenthesized_not_a_queryContext) + + // ExitParenthesized_in_rhs is called when exiting the parenthesized_in_rhs production. + ExitParenthesized_in_rhs(c *Parenthesized_in_rhsContext) + + // ExitUnary_operator is called when exiting the unary_operator production. + ExitUnary_operator(c *Unary_operatorContext) + + // ExitComparative_operator is called when exiting the comparative_operator production. + ExitComparative_operator(c *Comparative_operatorContext) + + // ExitShift_operator is called when exiting the shift_operator production. + ExitShift_operator(c *Shift_operatorContext) + + // ExitAdditive_operator is called when exiting the additive_operator production. + ExitAdditive_operator(c *Additive_operatorContext) + + // ExitMultiplicative_operator is called when exiting the multiplicative_operator production. + ExitMultiplicative_operator(c *Multiplicative_operatorContext) + + // ExitIs_operator is called when exiting the is_operator production. + ExitIs_operator(c *Is_operatorContext) + + // ExitBetween_operator is called when exiting the between_operator production. + ExitBetween_operator(c *Between_operatorContext) + + // ExitIn_operator is called when exiting the in_operator production. + ExitIn_operator(c *In_operatorContext) + + // ExitDistinct_operator is called when exiting the distinct_operator production. + ExitDistinct_operator(c *Distinct_operatorContext) + + // ExitParenthesized_query is called when exiting the parenthesized_query production. + ExitParenthesized_query(c *Parenthesized_queryContext) + + // ExitParenthesized_expression_not_a_query is called when exiting the parenthesized_expression_not_a_query production. + ExitParenthesized_expression_not_a_query(c *Parenthesized_expression_not_a_queryContext) + + // ExitParenthesized_anysomeall_list_in_rhs is called when exiting the parenthesized_anysomeall_list_in_rhs production. + ExitParenthesized_anysomeall_list_in_rhs(c *Parenthesized_anysomeall_list_in_rhsContext) + + // ExitAnd_expression is called when exiting the and_expression production. + ExitAnd_expression(c *And_expressionContext) + + // ExitIn_list_two_or_more_prefix is called when exiting the in_list_two_or_more_prefix production. + ExitIn_list_two_or_more_prefix(c *In_list_two_or_more_prefixContext) + + // ExitAny_some_all is called when exiting the any_some_all production. + ExitAny_some_all(c *Any_some_allContext) + + // ExitLike_operator is called when exiting the like_operator production. + ExitLike_operator(c *Like_operatorContext) + + // ExitExpression_subquery_with_keyword is called when exiting the expression_subquery_with_keyword production. + ExitExpression_subquery_with_keyword(c *Expression_subquery_with_keywordContext) + + // ExitStruct_constructor is called when exiting the struct_constructor production. + ExitStruct_constructor(c *Struct_constructorContext) + + // ExitStruct_constructor_prefix_with_keyword is called when exiting the struct_constructor_prefix_with_keyword production. + ExitStruct_constructor_prefix_with_keyword(c *Struct_constructor_prefix_with_keywordContext) + + // ExitStruct_constructor_arg is called when exiting the struct_constructor_arg production. + ExitStruct_constructor_arg(c *Struct_constructor_argContext) + + // ExitStruct_constructor_prefix_without_keyword is called when exiting the struct_constructor_prefix_without_keyword production. + ExitStruct_constructor_prefix_without_keyword(c *Struct_constructor_prefix_without_keywordContext) + + // ExitStruct_constructor_prefix_with_keyword_no_arg is called when exiting the struct_constructor_prefix_with_keyword_no_arg production. + ExitStruct_constructor_prefix_with_keyword_no_arg(c *Struct_constructor_prefix_with_keyword_no_argContext) + + // ExitInterval_expression is called when exiting the interval_expression production. + ExitInterval_expression(c *Interval_expressionContext) + + // ExitFunction_call_expression_with_clauses is called when exiting the function_call_expression_with_clauses production. + ExitFunction_call_expression_with_clauses(c *Function_call_expression_with_clausesContext) + + // ExitFunction_call_expression_with_clauses_suffix is called when exiting the function_call_expression_with_clauses_suffix production. + ExitFunction_call_expression_with_clauses_suffix(c *Function_call_expression_with_clauses_suffixContext) + + // ExitOver_clause is called when exiting the over_clause production. + ExitOver_clause(c *Over_clauseContext) + + // ExitWindow_specification is called when exiting the window_specification production. + ExitWindow_specification(c *Window_specificationContext) + + // ExitOpt_window_frame_clause is called when exiting the opt_window_frame_clause production. + ExitOpt_window_frame_clause(c *Opt_window_frame_clauseContext) + + // ExitWindow_frame_bound is called when exiting the window_frame_bound production. + ExitWindow_frame_bound(c *Window_frame_boundContext) + + // ExitPreceding_or_following is called when exiting the preceding_or_following production. + ExitPreceding_or_following(c *Preceding_or_followingContext) + + // ExitFrame_unit is called when exiting the frame_unit production. + ExitFrame_unit(c *Frame_unitContext) + + // ExitPartition_by_clause is called when exiting the partition_by_clause production. + ExitPartition_by_clause(c *Partition_by_clauseContext) + + // ExitPartition_by_clause_prefix is called when exiting the partition_by_clause_prefix production. + ExitPartition_by_clause_prefix(c *Partition_by_clause_prefixContext) + + // ExitWith_group_rows is called when exiting the with_group_rows production. + ExitWith_group_rows(c *With_group_rowsContext) + + // ExitWith_report_modifier is called when exiting the with_report_modifier production. + ExitWith_report_modifier(c *With_report_modifierContext) + + // ExitClamped_between_modifier is called when exiting the clamped_between_modifier production. + ExitClamped_between_modifier(c *Clamped_between_modifierContext) + + // ExitWith_report_format is called when exiting the with_report_format production. + ExitWith_report_format(c *With_report_formatContext) + + // ExitOptions_list is called when exiting the options_list production. + ExitOptions_list(c *Options_listContext) + + // ExitOptions_list_prefix is called when exiting the options_list_prefix production. + ExitOptions_list_prefix(c *Options_list_prefixContext) + + // ExitOptions_entry is called when exiting the options_entry production. + ExitOptions_entry(c *Options_entryContext) + + // ExitExpression_or_proto is called when exiting the expression_or_proto production. + ExitExpression_or_proto(c *Expression_or_protoContext) + + // ExitOptions_assignment_operator is called when exiting the options_assignment_operator production. + ExitOptions_assignment_operator(c *Options_assignment_operatorContext) + + // ExitOpt_null_handling_modifier is called when exiting the opt_null_handling_modifier production. + ExitOpt_null_handling_modifier(c *Opt_null_handling_modifierContext) + + // ExitFunction_call_argument is called when exiting the function_call_argument production. + ExitFunction_call_argument(c *Function_call_argumentContext) + + // ExitSequence_arg is called when exiting the sequence_arg production. + ExitSequence_arg(c *Sequence_argContext) + + // ExitNamed_argument is called when exiting the named_argument production. + ExitNamed_argument(c *Named_argumentContext) + + // ExitLambda_argument is called when exiting the lambda_argument production. + ExitLambda_argument(c *Lambda_argumentContext) + + // ExitLambda_argument_list is called when exiting the lambda_argument_list production. + ExitLambda_argument_list(c *Lambda_argument_listContext) + + // ExitLimit_offset_clause is called when exiting the limit_offset_clause production. + ExitLimit_offset_clause(c *Limit_offset_clauseContext) + + // ExitOpt_having_or_group_by_modifier is called when exiting the opt_having_or_group_by_modifier production. + ExitOpt_having_or_group_by_modifier(c *Opt_having_or_group_by_modifierContext) + + // ExitGroup_by_clause_prefix is called when exiting the group_by_clause_prefix production. + ExitGroup_by_clause_prefix(c *Group_by_clause_prefixContext) + + // ExitGroup_by_preamble is called when exiting the group_by_preamble production. + ExitGroup_by_preamble(c *Group_by_preambleContext) + + // ExitOpt_and_order is called when exiting the opt_and_order production. + ExitOpt_and_order(c *Opt_and_orderContext) + + // ExitHint is called when exiting the hint production. + ExitHint(c *HintContext) + + // ExitHint_with_body is called when exiting the hint_with_body production. + ExitHint_with_body(c *Hint_with_bodyContext) + + // ExitHint_with_body_prefix is called when exiting the hint_with_body_prefix production. + ExitHint_with_body_prefix(c *Hint_with_body_prefixContext) + + // ExitHint_entry is called when exiting the hint_entry production. + ExitHint_entry(c *Hint_entryContext) + + // ExitIdentifier_in_hints is called when exiting the identifier_in_hints production. + ExitIdentifier_in_hints(c *Identifier_in_hintsContext) + + // ExitExtra_identifier_in_hints_name is called when exiting the extra_identifier_in_hints_name production. + ExitExtra_identifier_in_hints_name(c *Extra_identifier_in_hints_nameContext) + + // ExitGrouping_item is called when exiting the grouping_item production. + ExitGrouping_item(c *Grouping_itemContext) + + // ExitGrouping_set_list is called when exiting the grouping_set_list production. + ExitGrouping_set_list(c *Grouping_set_listContext) + + // ExitGrouping_set is called when exiting the grouping_set production. + ExitGrouping_set(c *Grouping_setContext) + + // ExitCube_list is called when exiting the cube_list production. + ExitCube_list(c *Cube_listContext) + + // ExitRollup_list is called when exiting the rollup_list production. + ExitRollup_list(c *Rollup_listContext) + + // ExitOpt_as_alias_with_required_as is called when exiting the opt_as_alias_with_required_as production. + ExitOpt_as_alias_with_required_as(c *Opt_as_alias_with_required_asContext) + + // ExitOpt_grouping_item_order is called when exiting the opt_grouping_item_order production. + ExitOpt_grouping_item_order(c *Opt_grouping_item_orderContext) + + // ExitOpt_selection_item_order is called when exiting the opt_selection_item_order production. + ExitOpt_selection_item_order(c *Opt_selection_item_orderContext) + + // ExitAsc_or_desc is called when exiting the asc_or_desc production. + ExitAsc_or_desc(c *Asc_or_descContext) + + // ExitNull_order is called when exiting the null_order production. + ExitNull_order(c *Null_orderContext) + + // ExitFunction_name_from_keyword is called when exiting the function_name_from_keyword production. + ExitFunction_name_from_keyword(c *Function_name_from_keywordContext) + + // ExitReplace_fields_expression is called when exiting the replace_fields_expression production. + ExitReplace_fields_expression(c *Replace_fields_expressionContext) + + // ExitReplace_fields_prefix is called when exiting the replace_fields_prefix production. + ExitReplace_fields_prefix(c *Replace_fields_prefixContext) + + // ExitReplace_fields_arg is called when exiting the replace_fields_arg production. + ExitReplace_fields_arg(c *Replace_fields_argContext) + + // ExitGeneralized_path_expression is called when exiting the generalized_path_expression production. + ExitGeneralized_path_expression(c *Generalized_path_expressionContext) + + // ExitGeneralized_extension_path is called when exiting the generalized_extension_path production. + ExitGeneralized_extension_path(c *Generalized_extension_pathContext) + + // ExitWith_expression is called when exiting the with_expression production. + ExitWith_expression(c *With_expressionContext) + + // ExitWith_expression_variable_prefix is called when exiting the with_expression_variable_prefix production. + ExitWith_expression_variable_prefix(c *With_expression_variable_prefixContext) + + // ExitWith_expression_variable is called when exiting the with_expression_variable production. + ExitWith_expression_variable(c *With_expression_variableContext) + + // ExitExtract_expression is called when exiting the extract_expression production. + ExitExtract_expression(c *Extract_expressionContext) + + // ExitExtract_expression_base is called when exiting the extract_expression_base production. + ExitExtract_expression_base(c *Extract_expression_baseContext) + + // ExitOpt_format is called when exiting the opt_format production. + ExitOpt_format(c *Opt_formatContext) + + // ExitOpt_at_time_zone is called when exiting the opt_at_time_zone production. + ExitOpt_at_time_zone(c *Opt_at_time_zoneContext) + + // ExitCast_expression is called when exiting the cast_expression production. + ExitCast_expression(c *Cast_expressionContext) + + // ExitCase_expression is called when exiting the case_expression production. + ExitCase_expression(c *Case_expressionContext) + + // ExitCase_expression_prefix is called when exiting the case_expression_prefix production. + ExitCase_expression_prefix(c *Case_expression_prefixContext) + + // ExitCase_value_expression_prefix is called when exiting the case_value_expression_prefix production. + ExitCase_value_expression_prefix(c *Case_value_expression_prefixContext) + + // ExitCase_no_value_expression_prefix is called when exiting the case_no_value_expression_prefix production. + ExitCase_no_value_expression_prefix(c *Case_no_value_expression_prefixContext) + + // ExitStruct_braced_constructor is called when exiting the struct_braced_constructor production. + ExitStruct_braced_constructor(c *Struct_braced_constructorContext) + + // ExitBraced_new_constructor is called when exiting the braced_new_constructor production. + ExitBraced_new_constructor(c *Braced_new_constructorContext) + + // ExitBraced_constructor is called when exiting the braced_constructor production. + ExitBraced_constructor(c *Braced_constructorContext) + + // ExitBraced_constructor_start is called when exiting the braced_constructor_start production. + ExitBraced_constructor_start(c *Braced_constructor_startContext) + + // ExitBraced_constructor_prefix is called when exiting the braced_constructor_prefix production. + ExitBraced_constructor_prefix(c *Braced_constructor_prefixContext) + + // ExitBraced_constructor_field is called when exiting the braced_constructor_field production. + ExitBraced_constructor_field(c *Braced_constructor_fieldContext) + + // ExitBraced_constructor_lhs is called when exiting the braced_constructor_lhs production. + ExitBraced_constructor_lhs(c *Braced_constructor_lhsContext) + + // ExitBraced_constructor_field_value is called when exiting the braced_constructor_field_value production. + ExitBraced_constructor_field_value(c *Braced_constructor_field_valueContext) + + // ExitBraced_constructor_extension is called when exiting the braced_constructor_extension production. + ExitBraced_constructor_extension(c *Braced_constructor_extensionContext) + + // ExitNew_constructor is called when exiting the new_constructor production. + ExitNew_constructor(c *New_constructorContext) + + // ExitNew_constructor_prefix is called when exiting the new_constructor_prefix production. + ExitNew_constructor_prefix(c *New_constructor_prefixContext) + + // ExitNew_constructor_prefix_no_arg is called when exiting the new_constructor_prefix_no_arg production. + ExitNew_constructor_prefix_no_arg(c *New_constructor_prefix_no_argContext) + + // ExitNew_constructor_arg is called when exiting the new_constructor_arg production. + ExitNew_constructor_arg(c *New_constructor_argContext) + + // ExitArray_constructor is called when exiting the array_constructor production. + ExitArray_constructor(c *Array_constructorContext) + + // ExitArray_constructor_prefix is called when exiting the array_constructor_prefix production. + ExitArray_constructor_prefix(c *Array_constructor_prefixContext) + + // ExitArray_constructor_prefix_no_expressions is called when exiting the array_constructor_prefix_no_expressions production. + ExitArray_constructor_prefix_no_expressions(c *Array_constructor_prefix_no_expressionsContext) + + // ExitRange_literal is called when exiting the range_literal production. + ExitRange_literal(c *Range_literalContext) + + // ExitRange_type is called when exiting the range_type production. + ExitRange_type(c *Range_typeContext) + + // ExitType is called when exiting the type production. + ExitType(c *TypeContext) + + // ExitCollate_clause is called when exiting the collate_clause production. + ExitCollate_clause(c *Collate_clauseContext) + + // ExitString_literal_or_parameter is called when exiting the string_literal_or_parameter production. + ExitString_literal_or_parameter(c *String_literal_or_parameterContext) + + // ExitSystem_variable_expression is called when exiting the system_variable_expression production. + ExitSystem_variable_expression(c *System_variable_expressionContext) + + // ExitParameter_expression is called when exiting the parameter_expression production. + ExitParameter_expression(c *Parameter_expressionContext) + + // ExitNamed_parameter_expression is called when exiting the named_parameter_expression production. + ExitNamed_parameter_expression(c *Named_parameter_expressionContext) + + // ExitOpt_type_parameters is called when exiting the opt_type_parameters production. + ExitOpt_type_parameters(c *Opt_type_parametersContext) + + // ExitType_parameters_prefix is called when exiting the type_parameters_prefix production. + ExitType_parameters_prefix(c *Type_parameters_prefixContext) + + // ExitType_parameter is called when exiting the type_parameter production. + ExitType_parameter(c *Type_parameterContext) + + // ExitRaw_type is called when exiting the raw_type production. + ExitRaw_type(c *Raw_typeContext) + + // ExitMap_type is called when exiting the map_type production. + ExitMap_type(c *Map_typeContext) + + // ExitFunction_type is called when exiting the function_type production. + ExitFunction_type(c *Function_typeContext) + + // ExitFunction_type_prefix is called when exiting the function_type_prefix production. + ExitFunction_type_prefix(c *Function_type_prefixContext) + + // ExitType_name is called when exiting the type_name production. + ExitType_name(c *Type_nameContext) + + // ExitPath_expression is called when exiting the path_expression production. + ExitPath_expression(c *Path_expressionContext) + + // ExitIdentifier is called when exiting the identifier production. + ExitIdentifier(c *IdentifierContext) + + // ExitKeyword_as_identifier is called when exiting the keyword_as_identifier production. + ExitKeyword_as_identifier(c *Keyword_as_identifierContext) + + // ExitCommon_keyword_as_identifier is called when exiting the common_keyword_as_identifier production. + ExitCommon_keyword_as_identifier(c *Common_keyword_as_identifierContext) + + // ExitToken_identifier is called when exiting the token_identifier production. + ExitToken_identifier(c *Token_identifierContext) + + // ExitStruct_type is called when exiting the struct_type production. + ExitStruct_type(c *Struct_typeContext) + + // ExitStruct_type_prefix is called when exiting the struct_type_prefix production. + ExitStruct_type_prefix(c *Struct_type_prefixContext) + + // ExitStruct_field is called when exiting the struct_field production. + ExitStruct_field(c *Struct_fieldContext) + + // ExitArray_type is called when exiting the array_type production. + ExitArray_type(c *Array_typeContext) + + // ExitTemplate_type_open is called when exiting the template_type_open production. + ExitTemplate_type_open(c *Template_type_openContext) + + // ExitTemplate_type_close is called when exiting the template_type_close production. + ExitTemplate_type_close(c *Template_type_closeContext) + + // ExitDate_or_time_literal is called when exiting the date_or_time_literal production. + ExitDate_or_time_literal(c *Date_or_time_literalContext) + + // ExitDate_or_time_literal_kind is called when exiting the date_or_time_literal_kind production. + ExitDate_or_time_literal_kind(c *Date_or_time_literal_kindContext) + + // ExitFloating_point_literal is called when exiting the floating_point_literal production. + ExitFloating_point_literal(c *Floating_point_literalContext) + + // ExitJson_literal is called when exiting the json_literal production. + ExitJson_literal(c *Json_literalContext) + + // ExitBignumeric_literal is called when exiting the bignumeric_literal production. + ExitBignumeric_literal(c *Bignumeric_literalContext) + + // ExitBignumeric_literal_prefix is called when exiting the bignumeric_literal_prefix production. + ExitBignumeric_literal_prefix(c *Bignumeric_literal_prefixContext) + + // ExitNumeric_literal is called when exiting the numeric_literal production. + ExitNumeric_literal(c *Numeric_literalContext) + + // ExitNumeric_literal_prefix is called when exiting the numeric_literal_prefix production. + ExitNumeric_literal_prefix(c *Numeric_literal_prefixContext) + + // ExitInteger_literal is called when exiting the integer_literal production. + ExitInteger_literal(c *Integer_literalContext) + + // ExitBytes_literal is called when exiting the bytes_literal production. + ExitBytes_literal(c *Bytes_literalContext) + + // ExitNull_literal is called when exiting the null_literal production. + ExitNull_literal(c *Null_literalContext) + + // ExitBoolean_literal is called when exiting the boolean_literal production. + ExitBoolean_literal(c *Boolean_literalContext) + + // ExitString_literal is called when exiting the string_literal production. + ExitString_literal(c *String_literalContext) + + // ExitString_literal_component is called when exiting the string_literal_component production. + ExitString_literal_component(c *String_literal_componentContext) + + // ExitBytes_literal_component is called when exiting the bytes_literal_component production. + ExitBytes_literal_component(c *Bytes_literal_componentContext) +} diff --git a/googlesql/googlesqlparser_visitor.go b/googlesql/googlesqlparser_visitor.go new file mode 100644 index 0000000..c051a0b --- /dev/null +++ b/googlesql/googlesqlparser_visitor.go @@ -0,0 +1,1884 @@ +// Code generated from GoogleSQLParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package googlesql // GoogleSQLParser +import "github.com/antlr4-go/antlr/v4" + +// A complete Visitor for a parse tree produced by GoogleSQLParser. +type GoogleSQLParserVisitor interface { + antlr.ParseTreeVisitor + + // Visit a parse tree produced by GoogleSQLParser#root. + VisitRoot(ctx *RootContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#stmts. + VisitStmts(ctx *StmtsContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#unterminated_sql_statement. + VisitUnterminated_sql_statement(ctx *Unterminated_sql_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#sql_statement_body. + VisitSql_statement_body(ctx *Sql_statement_bodyContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#gql_statement. + VisitGql_statement(ctx *Gql_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_operation_block. + VisitGraph_operation_block(ctx *Graph_operation_blockContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_composite_query_block. + VisitGraph_composite_query_block(ctx *Graph_composite_query_blockContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_composite_query_prefix. + VisitGraph_composite_query_prefix(ctx *Graph_composite_query_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_set_operation_metadata. + VisitGraph_set_operation_metadata(ctx *Graph_set_operation_metadataContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_linear_query_operation. + VisitGraph_linear_query_operation(ctx *Graph_linear_query_operationContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_linear_operator_list. + VisitGraph_linear_operator_list(ctx *Graph_linear_operator_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_linear_operator. + VisitGraph_linear_operator(ctx *Graph_linear_operatorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_sample_clause. + VisitGraph_sample_clause(ctx *Graph_sample_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_graph_sample_clause_suffix. + VisitOpt_graph_sample_clause_suffix(ctx *Opt_graph_sample_clause_suffixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_for_operator. + VisitGraph_for_operator(ctx *Graph_for_operatorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_with_offset_and_alias_with_required_as. + VisitOpt_with_offset_and_alias_with_required_as(ctx *Opt_with_offset_and_alias_with_required_asContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_with_operator. + VisitGraph_with_operator(ctx *Graph_with_operatorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_page_operator. + VisitGraph_page_operator(ctx *Graph_page_operatorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_order_by_operator. + VisitGraph_order_by_operator(ctx *Graph_order_by_operatorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_filter_operator. + VisitGraph_filter_operator(ctx *Graph_filter_operatorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_let_operator. + VisitGraph_let_operator(ctx *Graph_let_operatorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_let_variable_definition_list. + VisitGraph_let_variable_definition_list(ctx *Graph_let_variable_definition_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_let_variable_definition. + VisitGraph_let_variable_definition(ctx *Graph_let_variable_definitionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_optional_match_operator. + VisitGraph_optional_match_operator(ctx *Graph_optional_match_operatorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_match_operator. + VisitGraph_match_operator(ctx *Graph_match_operatorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_pattern. + VisitGraph_pattern(ctx *Graph_patternContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_path_pattern_list. + VisitGraph_path_pattern_list(ctx *Graph_path_pattern_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_path_pattern. + VisitGraph_path_pattern(ctx *Graph_path_patternContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_path_pattern_expr. + VisitGraph_path_pattern_expr(ctx *Graph_path_pattern_exprContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_path_factor. + VisitGraph_path_factor(ctx *Graph_path_factorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_quantified_path_primary. + VisitGraph_quantified_path_primary(ctx *Graph_quantified_path_primaryContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_path_primary. + VisitGraph_path_primary(ctx *Graph_path_primaryContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_parenthesized_path_pattern. + VisitGraph_parenthesized_path_pattern(ctx *Graph_parenthesized_path_patternContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_element_pattern. + VisitGraph_element_pattern(ctx *Graph_element_patternContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_edge_pattern. + VisitGraph_edge_pattern(ctx *Graph_edge_patternContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_node_pattern. + VisitGraph_node_pattern(ctx *Graph_node_patternContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_element_pattern_filler. + VisitGraph_element_pattern_filler(ctx *Graph_element_pattern_fillerContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_property_specification. + VisitGraph_property_specification(ctx *Graph_property_specificationContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_property_name_and_value. + VisitGraph_property_name_and_value(ctx *Graph_property_name_and_valueContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_is_label_expression. + VisitOpt_is_label_expression(ctx *Opt_is_label_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#label_expression. + VisitLabel_expression(ctx *Label_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#label_primary. + VisitLabel_primary(ctx *Label_primaryContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#parenthesized_label_expression. + VisitParenthesized_label_expression(ctx *Parenthesized_label_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_graph_element_identifier. + VisitOpt_graph_element_identifier(ctx *Opt_graph_element_identifierContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_graph_path_mode_prefix. + VisitOpt_graph_path_mode_prefix(ctx *Opt_graph_path_mode_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#path_or_paths. + VisitPath_or_paths(ctx *Path_or_pathsContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_graph_path_mode. + VisitOpt_graph_path_mode(ctx *Opt_graph_path_modeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_graph_search_prefix. + VisitOpt_graph_search_prefix(ctx *Opt_graph_search_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_path_variable_assignment. + VisitOpt_path_variable_assignment(ctx *Opt_path_variable_assignmentContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_identifier. + VisitGraph_identifier(ctx *Graph_identifierContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_return_operator. + VisitGraph_return_operator(ctx *Graph_return_operatorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_page_clause. + VisitGraph_page_clause(ctx *Graph_page_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_order_by_clause. + VisitGraph_order_by_clause(ctx *Graph_order_by_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_ordering_expression. + VisitGraph_ordering_expression(ctx *Graph_ordering_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_graph_asc_or_desc. + VisitOpt_graph_asc_or_desc(ctx *Opt_graph_asc_or_descContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_return_item_list. + VisitGraph_return_item_list(ctx *Graph_return_item_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#graph_return_item. + VisitGraph_return_item(ctx *Graph_return_itemContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#undrop_statement. + VisitUndrop_statement(ctx *Undrop_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#module_statement. + VisitModule_statement(ctx *Module_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#import_statement. + VisitImport_statement(ctx *Import_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_as_or_into_alias. + VisitOpt_as_or_into_alias(ctx *Opt_as_or_into_aliasContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#path_expression_or_string. + VisitPath_expression_or_string(ctx *Path_expression_or_stringContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#import_type. + VisitImport_type(ctx *Import_typeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#call_statement. + VisitCall_statement(ctx *Call_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#drop_statement. + VisitDrop_statement(ctx *Drop_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_drop_mode. + VisitOpt_drop_mode(ctx *Opt_drop_modeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#drop_all_row_access_policies_statement. + VisitDrop_all_row_access_policies_statement(ctx *Drop_all_row_access_policies_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#show_statement. + VisitShow_statement(ctx *Show_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_like_string_literal. + VisitOpt_like_string_literal(ctx *Opt_like_string_literalContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#show_target. + VisitShow_target(ctx *Show_targetContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#rename_statement. + VisitRename_statement(ctx *Rename_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#revoke_statement. + VisitRevoke_statement(ctx *Revoke_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#grant_statement. + VisitGrant_statement(ctx *Grant_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#privileges. + VisitPrivileges(ctx *PrivilegesContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#export_metadata_statement. + VisitExport_metadata_statement(ctx *Export_metadata_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#export_model_statement. + VisitExport_model_statement(ctx *Export_model_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#export_data_statement. + VisitExport_data_statement(ctx *Export_data_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#export_data_no_query. + VisitExport_data_no_query(ctx *Export_data_no_queryContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#explain_statement. + VisitExplain_statement(ctx *Explain_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#execute_immediate. + VisitExecute_immediate(ctx *Execute_immediateContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_execute_into_clause. + VisitOpt_execute_into_clause(ctx *Opt_execute_into_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_execute_using_clause. + VisitOpt_execute_using_clause(ctx *Opt_execute_using_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#execute_using_argument_list. + VisitExecute_using_argument_list(ctx *Execute_using_argument_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#execute_using_argument. + VisitExecute_using_argument(ctx *Execute_using_argumentContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#describe_statement. + VisitDescribe_statement(ctx *Describe_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#describe_info. + VisitDescribe_info(ctx *Describe_infoContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_from_path_expression. + VisitOpt_from_path_expression(ctx *Opt_from_path_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#describe_keyword. + VisitDescribe_keyword(ctx *Describe_keywordContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#define_table_statement. + VisitDefine_table_statement(ctx *Define_table_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#create_entity_statement. + VisitCreate_entity_statement(ctx *Create_entity_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_generic_entity_body. + VisitOpt_generic_entity_body(ctx *Opt_generic_entity_bodyContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#create_view_statement. + VisitCreate_view_statement(ctx *Create_view_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#query_or_replica_source. + VisitQuery_or_replica_source(ctx *Query_or_replica_sourceContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#column_with_options_list. + VisitColumn_with_options_list(ctx *Column_with_options_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#column_with_options. + VisitColumn_with_options(ctx *Column_with_optionsContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#create_table_statement. + VisitCreate_table_statement(ctx *Create_table_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_ttl_clause. + VisitOpt_ttl_clause(ctx *Opt_ttl_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_copy_table. + VisitOpt_copy_table(ctx *Opt_copy_tableContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#copy_data_source. + VisitCopy_data_source(ctx *Copy_data_sourceContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_clone_table. + VisitOpt_clone_table(ctx *Opt_clone_tableContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_spanner_table_options. + VisitOpt_spanner_table_options(ctx *Opt_spanner_table_optionsContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_spanner_interleave_in_parent_clause. + VisitOpt_spanner_interleave_in_parent_clause(ctx *Opt_spanner_interleave_in_parent_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#spanner_primary_key. + VisitSpanner_primary_key(ctx *Spanner_primary_keyContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#create_table_function_statement. + VisitCreate_table_function_statement(ctx *Create_table_function_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_as_query_or_string. + VisitOpt_as_query_or_string(ctx *Opt_as_query_or_stringContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#unordered_language_options. + VisitUnordered_language_options(ctx *Unordered_language_optionsContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_function_parameters. + VisitOpt_function_parameters(ctx *Opt_function_parametersContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#create_snapshot_statement. + VisitCreate_snapshot_statement(ctx *Create_snapshot_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#create_external_schema_statement. + VisitCreate_external_schema_statement(ctx *Create_external_schema_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#create_schema_statement. + VisitCreate_schema_statement(ctx *Create_schema_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#create_property_graph_statement. + VisitCreate_property_graph_statement(ctx *Create_property_graph_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_edge_table_clause. + VisitOpt_edge_table_clause(ctx *Opt_edge_table_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#element_table_list. + VisitElement_table_list(ctx *Element_table_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#element_table_definition. + VisitElement_table_definition(ctx *Element_table_definitionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_label_and_properties_clause. + VisitOpt_label_and_properties_clause(ctx *Opt_label_and_properties_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#label_and_properties_list. + VisitLabel_and_properties_list(ctx *Label_and_properties_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#label_and_properties. + VisitLabel_and_properties(ctx *Label_and_propertiesContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#properties_clause. + VisitProperties_clause(ctx *Properties_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#derived_property_list. + VisitDerived_property_list(ctx *Derived_property_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#derived_property. + VisitDerived_property(ctx *Derived_propertyContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_except_column_list. + VisitOpt_except_column_list(ctx *Opt_except_column_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#properties_all_columns. + VisitProperties_all_columns(ctx *Properties_all_columnsContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_dest_node_table_clause. + VisitOpt_dest_node_table_clause(ctx *Opt_dest_node_table_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_source_node_table_clause. + VisitOpt_source_node_table_clause(ctx *Opt_source_node_table_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_key_clause. + VisitOpt_key_clause(ctx *Opt_key_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#create_model_statement. + VisitCreate_model_statement(ctx *Create_model_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_input_output_clause. + VisitOpt_input_output_clause(ctx *Opt_input_output_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_transform_clause. + VisitOpt_transform_clause(ctx *Opt_transform_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_as_query_or_aliased_query_list. + VisitOpt_as_query_or_aliased_query_list(ctx *Opt_as_query_or_aliased_query_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#aliased_query_list. + VisitAliased_query_list(ctx *Aliased_query_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#as_query. + VisitAs_query(ctx *As_queryContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#create_external_table_function_statement. + VisitCreate_external_table_function_statement(ctx *Create_external_table_function_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#create_external_table_statement. + VisitCreate_external_table_statement(ctx *Create_external_table_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_default_collate_clause. + VisitOpt_default_collate_clause(ctx *Opt_default_collate_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_like_path_expression. + VisitOpt_like_path_expression(ctx *Opt_like_path_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#create_row_access_policy_statement. + VisitCreate_row_access_policy_statement(ctx *Create_row_access_policy_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#filter_using_clause. + VisitFilter_using_clause(ctx *Filter_using_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#create_row_access_policy_grant_to_clause. + VisitCreate_row_access_policy_grant_to_clause(ctx *Create_row_access_policy_grant_to_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#create_privilege_restriction_statement. + VisitCreate_privilege_restriction_statement(ctx *Create_privilege_restriction_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#restrict_to_clause. + VisitRestrict_to_clause(ctx *Restrict_to_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#possibly_empty_grantee_list. + VisitPossibly_empty_grantee_list(ctx *Possibly_empty_grantee_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#create_index_statement. + VisitCreate_index_statement(ctx *Create_index_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_create_index_statement_suffix. + VisitOpt_create_index_statement_suffix(ctx *Opt_create_index_statement_suffixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#spanner_index_interleave_clause. + VisitSpanner_index_interleave_clause(ctx *Spanner_index_interleave_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#index_storing_list. + VisitIndex_storing_list(ctx *Index_storing_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#index_storing_expression_list. + VisitIndex_storing_expression_list(ctx *Index_storing_expression_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#index_order_by_and_options. + VisitIndex_order_by_and_options(ctx *Index_order_by_and_optionsContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#index_all_columns. + VisitIndex_all_columns(ctx *Index_all_columnsContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_with_column_options. + VisitOpt_with_column_options(ctx *Opt_with_column_optionsContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#all_column_column_options. + VisitAll_column_column_options(ctx *All_column_column_optionsContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#column_ordering_and_options_expr. + VisitColumn_ordering_and_options_expr(ctx *Column_ordering_and_options_exprContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#index_unnest_expression_list. + VisitIndex_unnest_expression_list(ctx *Index_unnest_expression_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#unnest_expression_with_opt_alias_and_offset. + VisitUnnest_expression_with_opt_alias_and_offset(ctx *Unnest_expression_with_opt_alias_and_offsetContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#on_path_expression. + VisitOn_path_expression(ctx *On_path_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#index_type. + VisitIndex_type(ctx *Index_typeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_spanner_null_filtered. + VisitOpt_spanner_null_filtered(ctx *Opt_spanner_null_filteredContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#create_procedure_statement. + VisitCreate_procedure_statement(ctx *Create_procedure_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#begin_end_block_or_language_as_code. + VisitBegin_end_block_or_language_as_code(ctx *Begin_end_block_or_language_as_codeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#begin_end_block. + VisitBegin_end_block(ctx *Begin_end_blockContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_exception_handler. + VisitOpt_exception_handler(ctx *Opt_exception_handlerContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#statement_list. + VisitStatement_list(ctx *Statement_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#unterminated_non_empty_statement_list. + VisitUnterminated_non_empty_statement_list(ctx *Unterminated_non_empty_statement_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#unterminated_statement. + VisitUnterminated_statement(ctx *Unterminated_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#unterminated_script_statement. + VisitUnterminated_script_statement(ctx *Unterminated_script_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#label. + VisitLabel(ctx *LabelContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#unterminated_unlabeled_script_statement. + VisitUnterminated_unlabeled_script_statement(ctx *Unterminated_unlabeled_script_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#for_in_statement. + VisitFor_in_statement(ctx *For_in_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#repeat_statement. + VisitRepeat_statement(ctx *Repeat_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#until_clause. + VisitUntil_clause(ctx *Until_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#loop_statement. + VisitLoop_statement(ctx *Loop_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#while_statement. + VisitWhile_statement(ctx *While_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#raise_statement. + VisitRaise_statement(ctx *Raise_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#return_statement. + VisitReturn_statement(ctx *Return_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#continue_statement. + VisitContinue_statement(ctx *Continue_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#variable_declaration. + VisitVariable_declaration(ctx *Variable_declarationContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#break_statement. + VisitBreak_statement(ctx *Break_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#case_statement. + VisitCase_statement(ctx *Case_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#when_then_clauses. + VisitWhen_then_clauses(ctx *When_then_clausesContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#if_statement. + VisitIf_statement(ctx *If_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#elseif_clauses. + VisitElseif_clauses(ctx *Elseif_clausesContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_else. + VisitOpt_else(ctx *Opt_elseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_as_code. + VisitOpt_as_code(ctx *Opt_as_codeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_external_security_clause. + VisitOpt_external_security_clause(ctx *Opt_external_security_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#external_security_clause_kind. + VisitExternal_security_clause_kind(ctx *External_security_clause_kindContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#procedure_parameters. + VisitProcedure_parameters(ctx *Procedure_parametersContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#procedure_parameter. + VisitProcedure_parameter(ctx *Procedure_parameterContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#procedure_parameter_termination. + VisitProcedure_parameter_termination(ctx *Procedure_parameter_terminationContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_procedure_parameter_mode. + VisitOpt_procedure_parameter_mode(ctx *Opt_procedure_parameter_modeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#create_function_statement. + VisitCreate_function_statement(ctx *Create_function_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_determinism_level. + VisitOpt_determinism_level(ctx *Opt_determinism_levelContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_sql_security_clause. + VisitOpt_sql_security_clause(ctx *Opt_sql_security_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#sql_security_clause_kind. + VisitSql_security_clause_kind(ctx *Sql_security_clause_kindContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#as_sql_function_body_or_string. + VisitAs_sql_function_body_or_string(ctx *As_sql_function_body_or_stringContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#sql_function_body. + VisitSql_function_body(ctx *Sql_function_bodyContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#unordered_options_body. + VisitUnordered_options_body(ctx *Unordered_options_bodyContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_language_or_remote_with_connection. + VisitOpt_language_or_remote_with_connection(ctx *Opt_language_or_remote_with_connectionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#language. + VisitLanguage(ctx *LanguageContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#remote_with_connection_clause. + VisitRemote_with_connection_clause(ctx *Remote_with_connection_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#with_connection_clause. + VisitWith_connection_clause(ctx *With_connection_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_function_returns. + VisitOpt_function_returns(ctx *Opt_function_returnsContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_returns. + VisitOpt_returns(ctx *Opt_returnsContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#function_declaration. + VisitFunction_declaration(ctx *Function_declarationContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#function_parameters. + VisitFunction_parameters(ctx *Function_parametersContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#function_parameter. + VisitFunction_parameter(ctx *Function_parameterContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_not_aggregate. + VisitOpt_not_aggregate(ctx *Opt_not_aggregateContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_default_expression. + VisitOpt_default_expression(ctx *Opt_default_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#type_or_tvf_schema. + VisitType_or_tvf_schema(ctx *Type_or_tvf_schemaContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#tvf_schema. + VisitTvf_schema(ctx *Tvf_schemaContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#tvf_schema_column. + VisitTvf_schema_column(ctx *Tvf_schema_columnContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#templated_parameter_type. + VisitTemplated_parameter_type(ctx *Templated_parameter_typeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#templated_parameter_kind. + VisitTemplated_parameter_kind(ctx *Templated_parameter_kindContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_aggregate. + VisitOpt_aggregate(ctx *Opt_aggregateContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#create_database_statement. + VisitCreate_database_statement(ctx *Create_database_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#create_connection_statement. + VisitCreate_connection_statement(ctx *Create_connection_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#create_constant_statement. + VisitCreate_constant_statement(ctx *Create_constant_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_or_replace. + VisitOpt_or_replace(ctx *Opt_or_replaceContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_create_scope. + VisitOpt_create_scope(ctx *Opt_create_scopeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#run_batch_statement. + VisitRun_batch_statement(ctx *Run_batch_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#abort_batch_statement. + VisitAbort_batch_statement(ctx *Abort_batch_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#start_batch_statement. + VisitStart_batch_statement(ctx *Start_batch_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#rollback_statement. + VisitRollback_statement(ctx *Rollback_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#commit_statement. + VisitCommit_statement(ctx *Commit_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#set_statement. + VisitSet_statement(ctx *Set_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#identifier_list. + VisitIdentifier_list(ctx *Identifier_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#begin_statement. + VisitBegin_statement(ctx *Begin_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#begin_transaction_keywords. + VisitBegin_transaction_keywords(ctx *Begin_transaction_keywordsContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#transaction_mode_list. + VisitTransaction_mode_list(ctx *Transaction_mode_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#transaction_mode. + VisitTransaction_mode(ctx *Transaction_modeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#truncate_statement. + VisitTruncate_statement(ctx *Truncate_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#merge_statement. + VisitMerge_statement(ctx *Merge_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#merge_source. + VisitMerge_source(ctx *Merge_sourceContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#merge_when_clause. + VisitMerge_when_clause(ctx *Merge_when_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#merge_action. + VisitMerge_action(ctx *Merge_actionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#merge_insert_value_list_or_source_row. + VisitMerge_insert_value_list_or_source_row(ctx *Merge_insert_value_list_or_source_rowContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#by_target. + VisitBy_target(ctx *By_targetContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_and_expression. + VisitOpt_and_expression(ctx *Opt_and_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#statement_level_hint. + VisitStatement_level_hint(ctx *Statement_level_hintContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#query_statement. + VisitQuery_statement(ctx *Query_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#dml_statement. + VisitDml_statement(ctx *Dml_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#update_statement. + VisitUpdate_statement(ctx *Update_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#delete_statement. + VisitDelete_statement(ctx *Delete_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#insert_statement. + VisitInsert_statement(ctx *Insert_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#on_conflict_clause. + VisitOn_conflict_clause(ctx *On_conflict_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_where_expression. + VisitOpt_where_expression(ctx *Opt_where_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_conflict_target. + VisitOpt_conflict_target(ctx *Opt_conflict_targetContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#update_item_list. + VisitUpdate_item_list(ctx *Update_item_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#update_item. + VisitUpdate_item(ctx *Update_itemContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#update_set_value. + VisitUpdate_set_value(ctx *Update_set_valueContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#nested_dml_statement. + VisitNested_dml_statement(ctx *Nested_dml_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#insert_values_list_or_table_clause. + VisitInsert_values_list_or_table_clause(ctx *Insert_values_list_or_table_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#table_clause_unreversed. + VisitTable_clause_unreversed(ctx *Table_clause_unreversedContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#table_clause_no_keyword. + VisitTable_clause_no_keyword(ctx *Table_clause_no_keywordContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_returning_clause. + VisitOpt_returning_clause(ctx *Opt_returning_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_assert_rows_modified. + VisitOpt_assert_rows_modified(ctx *Opt_assert_rows_modifiedContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#insert_values_or_query. + VisitInsert_values_or_query(ctx *Insert_values_or_queryContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#insert_values_list. + VisitInsert_values_list(ctx *Insert_values_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#insert_values_row. + VisitInsert_values_row(ctx *Insert_values_rowContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#expression_or_default. + VisitExpression_or_default(ctx *Expression_or_defaultContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#insert_statement_prefix. + VisitInsert_statement_prefix(ctx *Insert_statement_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#maybe_dashed_generalized_path_expression. + VisitMaybe_dashed_generalized_path_expression(ctx *Maybe_dashed_generalized_path_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_into. + VisitOpt_into(ctx *Opt_intoContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_or_ignore_replace_update. + VisitOpt_or_ignore_replace_update(ctx *Opt_or_ignore_replace_updateContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#alter_statement. + VisitAlter_statement(ctx *Alter_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#analyze_statement. + VisitAnalyze_statement(ctx *Analyze_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#assert_statement. + VisitAssert_statement(ctx *Assert_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#aux_load_data_statement. + VisitAux_load_data_statement(ctx *Aux_load_data_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#clone_data_statement. + VisitClone_data_statement(ctx *Clone_data_statementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#clone_data_source_list. + VisitClone_data_source_list(ctx *Clone_data_source_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#clone_data_source. + VisitClone_data_source(ctx *Clone_data_sourceContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_external_table_with_clauses. + VisitOpt_external_table_with_clauses(ctx *Opt_external_table_with_clausesContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#with_partition_columns_clause. + VisitWith_partition_columns_clause(ctx *With_partition_columns_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#aux_load_data_from_files_options_list. + VisitAux_load_data_from_files_options_list(ctx *Aux_load_data_from_files_options_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#cluster_by_clause_prefix_no_hint. + VisitCluster_by_clause_prefix_no_hint(ctx *Cluster_by_clause_prefix_no_hintContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#load_data_partitions_clause. + VisitLoad_data_partitions_clause(ctx *Load_data_partitions_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#maybe_dashed_path_expression_with_scope. + VisitMaybe_dashed_path_expression_with_scope(ctx *Maybe_dashed_path_expression_with_scopeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#table_element_list. + VisitTable_element_list(ctx *Table_element_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#table_element. + VisitTable_element(ctx *Table_elementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#table_constraint_definition. + VisitTable_constraint_definition(ctx *Table_constraint_definitionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#append_or_overwrite. + VisitAppend_or_overwrite(ctx *Append_or_overwriteContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_description. + VisitOpt_description(ctx *Opt_descriptionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#table_and_column_info_list. + VisitTable_and_column_info_list(ctx *Table_and_column_info_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#table_and_column_info. + VisitTable_and_column_info(ctx *Table_and_column_infoContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#row_access_policy_alter_action_list. + VisitRow_access_policy_alter_action_list(ctx *Row_access_policy_alter_action_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#row_access_policy_alter_action. + VisitRow_access_policy_alter_action(ctx *Row_access_policy_alter_actionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#grant_to_clause. + VisitGrant_to_clause(ctx *Grant_to_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#grantee_list. + VisitGrantee_list(ctx *Grantee_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#privilege_list. + VisitPrivilege_list(ctx *Privilege_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#privilege. + VisitPrivilege(ctx *PrivilegeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#path_expression_list_with_parens. + VisitPath_expression_list_with_parens(ctx *Path_expression_list_with_parensContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#privilege_name. + VisitPrivilege_name(ctx *Privilege_nameContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#generic_entity_type. + VisitGeneric_entity_type(ctx *Generic_entity_typeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#generic_entity_type_unchecked. + VisitGeneric_entity_type_unchecked(ctx *Generic_entity_type_uncheckedContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#schema_object_kind. + VisitSchema_object_kind(ctx *Schema_object_kindContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#alter_action_list. + VisitAlter_action_list(ctx *Alter_action_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#alter_action. + VisitAlter_action(ctx *Alter_actionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#spanner_set_on_delete_action. + VisitSpanner_set_on_delete_action(ctx *Spanner_set_on_delete_actionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#spanner_alter_column_action. + VisitSpanner_alter_column_action(ctx *Spanner_alter_column_actionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#spanner_generated_or_default. + VisitSpanner_generated_or_default(ctx *Spanner_generated_or_defaultContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#generic_sub_entity_type. + VisitGeneric_sub_entity_type(ctx *Generic_sub_entity_typeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#sub_entity_type_identifier. + VisitSub_entity_type_identifier(ctx *Sub_entity_type_identifierContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#fill_using_expression. + VisitFill_using_expression(ctx *Fill_using_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#column_position. + VisitColumn_position(ctx *Column_positionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#table_column_definition. + VisitTable_column_definition(ctx *Table_column_definitionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#column_attributes. + VisitColumn_attributes(ctx *Column_attributesContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#column_attribute. + VisitColumn_attribute(ctx *Column_attributeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#primary_key_column_attribute. + VisitPrimary_key_column_attribute(ctx *Primary_key_column_attributeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#foreign_key_column_attribute. + VisitForeign_key_column_attribute(ctx *Foreign_key_column_attributeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#hidden_column_attribute. + VisitHidden_column_attribute(ctx *Hidden_column_attributeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_constraint_identity. + VisitOpt_constraint_identity(ctx *Opt_constraint_identityContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#table_column_schema. + VisitTable_column_schema(ctx *Table_column_schemaContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_column_info. + VisitOpt_column_info(ctx *Opt_column_infoContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#invalid_generated_column. + VisitInvalid_generated_column(ctx *Invalid_generated_columnContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#invalid_default_column. + VisitInvalid_default_column(ctx *Invalid_default_columnContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#default_column_info. + VisitDefault_column_info(ctx *Default_column_infoContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#generated_column_info. + VisitGenerated_column_info(ctx *Generated_column_infoContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#identity_column_info. + VisitIdentity_column_info(ctx *Identity_column_infoContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_start_with. + VisitOpt_start_with(ctx *Opt_start_withContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_increment_by. + VisitOpt_increment_by(ctx *Opt_increment_byContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_maxvalue. + VisitOpt_maxvalue(ctx *Opt_maxvalueContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_minvalue. + VisitOpt_minvalue(ctx *Opt_minvalueContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_cycle. + VisitOpt_cycle(ctx *Opt_cycleContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#signed_numeric_literal. + VisitSigned_numeric_literal(ctx *Signed_numeric_literalContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#stored_mode. + VisitStored_mode(ctx *Stored_modeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#generated_mode. + VisitGenerated_mode(ctx *Generated_modeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#column_schema_inner. + VisitColumn_schema_inner(ctx *Column_schema_innerContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#raw_column_schema_inner. + VisitRaw_column_schema_inner(ctx *Raw_column_schema_innerContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#range_column_schema_inner. + VisitRange_column_schema_inner(ctx *Range_column_schema_innerContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#struct_column_schema_inner. + VisitStruct_column_schema_inner(ctx *Struct_column_schema_innerContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#struct_column_field. + VisitStruct_column_field(ctx *Struct_column_fieldContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#simple_column_schema_inner. + VisitSimple_column_schema_inner(ctx *Simple_column_schema_innerContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#array_column_schema_inner. + VisitArray_column_schema_inner(ctx *Array_column_schema_innerContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#field_schema. + VisitField_schema(ctx *Field_schemaContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_field_attributes. + VisitOpt_field_attributes(ctx *Opt_field_attributesContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#not_null_column_attribute. + VisitNot_null_column_attribute(ctx *Not_null_column_attributeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#primary_key_or_table_constraint_spec. + VisitPrimary_key_or_table_constraint_spec(ctx *Primary_key_or_table_constraint_specContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_if_not_exists. + VisitOpt_if_not_exists(ctx *Opt_if_not_existsContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#primary_key_spec. + VisitPrimary_key_spec(ctx *Primary_key_specContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#primary_key_element_list. + VisitPrimary_key_element_list(ctx *Primary_key_element_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#primary_key_element. + VisitPrimary_key_element(ctx *Primary_key_elementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#table_constraint_spec. + VisitTable_constraint_spec(ctx *Table_constraint_specContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#foreign_key_reference. + VisitForeign_key_reference(ctx *Foreign_key_referenceContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_foreign_key_action. + VisitOpt_foreign_key_action(ctx *Opt_foreign_key_actionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#foreign_key_on_update. + VisitForeign_key_on_update(ctx *Foreign_key_on_updateContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#foreign_key_on_delete. + VisitForeign_key_on_delete(ctx *Foreign_key_on_deleteContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#foreign_key_action. + VisitForeign_key_action(ctx *Foreign_key_actionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_foreign_key_match. + VisitOpt_foreign_key_match(ctx *Opt_foreign_key_matchContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#foreign_key_match_mode. + VisitForeign_key_match_mode(ctx *Foreign_key_match_modeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#column_list. + VisitColumn_list(ctx *Column_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_options_list. + VisitOpt_options_list(ctx *Opt_options_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#constraint_enforcement. + VisitConstraint_enforcement(ctx *Constraint_enforcementContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#generic_entity_body. + VisitGeneric_entity_body(ctx *Generic_entity_bodyContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_if_exists. + VisitOpt_if_exists(ctx *Opt_if_existsContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#table_or_table_function. + VisitTable_or_table_function(ctx *Table_or_table_functionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#query. + VisitQuery(ctx *QueryContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#query_without_pipe_operators. + VisitQuery_without_pipe_operators(ctx *Query_without_pipe_operatorsContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#bad_keyword_after_from_query. + VisitBad_keyword_after_from_query(ctx *Bad_keyword_after_from_queryContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#bad_keyword_after_from_query_allows_parens. + VisitBad_keyword_after_from_query_allows_parens(ctx *Bad_keyword_after_from_query_allows_parensContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#with_clause_with_trailing_comma. + VisitWith_clause_with_trailing_comma(ctx *With_clause_with_trailing_commaContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#select_or_from_keyword. + VisitSelect_or_from_keyword(ctx *Select_or_from_keywordContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#query_primary_or_set_operation. + VisitQuery_primary_or_set_operation(ctx *Query_primary_or_set_operationContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#query_set_operation. + VisitQuery_set_operation(ctx *Query_set_operationContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#query_set_operation_prefix. + VisitQuery_set_operation_prefix(ctx *Query_set_operation_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#query_set_operation_item. + VisitQuery_set_operation_item(ctx *Query_set_operation_itemContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#query_primary. + VisitQuery_primary(ctx *Query_primaryContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#set_operation_metadata. + VisitSet_operation_metadata(ctx *Set_operation_metadataContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_column_match_suffix. + VisitOpt_column_match_suffix(ctx *Opt_column_match_suffixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_strict. + VisitOpt_strict(ctx *Opt_strictContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#all_or_distinct. + VisitAll_or_distinct(ctx *All_or_distinctContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#query_set_operation_type. + VisitQuery_set_operation_type(ctx *Query_set_operation_typeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_corresponding_outer_mode. + VisitOpt_corresponding_outer_mode(ctx *Opt_corresponding_outer_modeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_outer. + VisitOpt_outer(ctx *Opt_outerContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#with_clause. + VisitWith_clause(ctx *With_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#aliased_query. + VisitAliased_query(ctx *Aliased_queryContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_aliased_query_modifiers. + VisitOpt_aliased_query_modifiers(ctx *Opt_aliased_query_modifiersContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#recursion_depth_modifier. + VisitRecursion_depth_modifier(ctx *Recursion_depth_modifierContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#possibly_unbounded_int_literal_or_parameter. + VisitPossibly_unbounded_int_literal_or_parameter(ctx *Possibly_unbounded_int_literal_or_parameterContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#int_literal_or_parameter. + VisitInt_literal_or_parameter(ctx *Int_literal_or_parameterContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#order_by_clause. + VisitOrder_by_clause(ctx *Order_by_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#order_by_clause_prefix. + VisitOrder_by_clause_prefix(ctx *Order_by_clause_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#ordering_expression. + VisitOrdering_expression(ctx *Ordering_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#select. + VisitSelect(ctx *SelectContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_clauses_following_from. + VisitOpt_clauses_following_from(ctx *Opt_clauses_following_fromContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_clauses_following_where. + VisitOpt_clauses_following_where(ctx *Opt_clauses_following_whereContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_clauses_following_group_by. + VisitOpt_clauses_following_group_by(ctx *Opt_clauses_following_group_byContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#window_clause. + VisitWindow_clause(ctx *Window_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#window_clause_prefix. + VisitWindow_clause_prefix(ctx *Window_clause_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#window_definition. + VisitWindow_definition(ctx *Window_definitionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#where_clause. + VisitWhere_clause(ctx *Where_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#having_clause. + VisitHaving_clause(ctx *Having_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#group_by_clause. + VisitGroup_by_clause(ctx *Group_by_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#group_by_all. + VisitGroup_by_all(ctx *Group_by_allContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#select_clause. + VisitSelect_clause(ctx *Select_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_select_as_clause. + VisitOpt_select_as_clause(ctx *Opt_select_as_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_select_with. + VisitOpt_select_with(ctx *Opt_select_withContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#from_clause. + VisitFrom_clause(ctx *From_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#from_clause_contents. + VisitFrom_clause_contents(ctx *From_clause_contentsContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#from_clause_contents_suffix. + VisitFrom_clause_contents_suffix(ctx *From_clause_contents_suffixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#table_primary. + VisitTable_primary(ctx *Table_primaryContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#tvf_with_suffixes. + VisitTvf_with_suffixes(ctx *Tvf_with_suffixesContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#pivot_or_unpivot_clause_and_aliases. + VisitPivot_or_unpivot_clause_and_aliases(ctx *Pivot_or_unpivot_clause_and_aliasesContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#as_alias. + VisitAs_alias(ctx *As_aliasContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#sample_clause. + VisitSample_clause(ctx *Sample_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_sample_clause_suffix. + VisitOpt_sample_clause_suffix(ctx *Opt_sample_clause_suffixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#repeatable_clause. + VisitRepeatable_clause(ctx *Repeatable_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#possibly_cast_int_literal_or_parameter. + VisitPossibly_cast_int_literal_or_parameter(ctx *Possibly_cast_int_literal_or_parameterContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#cast_int_literal_or_parameter. + VisitCast_int_literal_or_parameter(ctx *Cast_int_literal_or_parameterContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#sample_size. + VisitSample_size(ctx *Sample_sizeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#sample_size_value. + VisitSample_size_value(ctx *Sample_size_valueContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#sample_size_unit. + VisitSample_size_unit(ctx *Sample_size_unitContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#partition_by_clause_prefix_no_hint. + VisitPartition_by_clause_prefix_no_hint(ctx *Partition_by_clause_prefix_no_hintContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#match_recognize_clause. + VisitMatch_recognize_clause(ctx *Match_recognize_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#row_pattern_expr. + VisitRow_pattern_expr(ctx *Row_pattern_exprContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#row_pattern_concatenation. + VisitRow_pattern_concatenation(ctx *Row_pattern_concatenationContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#row_pattern_factor. + VisitRow_pattern_factor(ctx *Row_pattern_factorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#select_list_prefix_with_as_aliases. + VisitSelect_list_prefix_with_as_aliases(ctx *Select_list_prefix_with_as_aliasesContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#select_column_expr_with_as_alias. + VisitSelect_column_expr_with_as_alias(ctx *Select_column_expr_with_as_aliasContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#table_subquery. + VisitTable_subquery(ctx *Table_subqueryContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#join. + VisitJoin(ctx *JoinContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#join_item. + VisitJoin_item(ctx *Join_itemContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#on_or_using_clause_list. + VisitOn_or_using_clause_list(ctx *On_or_using_clause_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#on_or_using_clause. + VisitOn_or_using_clause(ctx *On_or_using_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#using_clause. + VisitUsing_clause(ctx *Using_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#join_hint. + VisitJoin_hint(ctx *Join_hintContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#table_path_expression. + VisitTable_path_expression(ctx *Table_path_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_at_system_time. + VisitOpt_at_system_time(ctx *Opt_at_system_timeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_with_offset_and_alias. + VisitOpt_with_offset_and_alias(ctx *Opt_with_offset_and_aliasContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_pivot_or_unpivot_clause_and_alias. + VisitOpt_pivot_or_unpivot_clause_and_alias(ctx *Opt_pivot_or_unpivot_clause_and_aliasContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#table_path_expression_base. + VisitTable_path_expression_base(ctx *Table_path_expression_baseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#maybe_slashed_or_dashed_path_expression. + VisitMaybe_slashed_or_dashed_path_expression(ctx *Maybe_slashed_or_dashed_path_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#maybe_dashed_path_expression. + VisitMaybe_dashed_path_expression(ctx *Maybe_dashed_path_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#dashed_path_expression. + VisitDashed_path_expression(ctx *Dashed_path_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#dashed_identifier. + VisitDashed_identifier(ctx *Dashed_identifierContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#slashed_identifier. + VisitSlashed_identifier(ctx *Slashed_identifierContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#identifier_or_integer. + VisitIdentifier_or_integer(ctx *Identifier_or_integerContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#slashed_identifier_separator. + VisitSlashed_identifier_separator(ctx *Slashed_identifier_separatorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#slashed_path_expression. + VisitSlashed_path_expression(ctx *Slashed_path_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#unnest_expression. + VisitUnnest_expression(ctx *Unnest_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#unnest_expression_prefix. + VisitUnnest_expression_prefix(ctx *Unnest_expression_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_array_zip_mode. + VisitOpt_array_zip_mode(ctx *Opt_array_zip_modeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#expression_with_opt_alias. + VisitExpression_with_opt_alias(ctx *Expression_with_opt_aliasContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#tvf_prefix. + VisitTvf_prefix(ctx *Tvf_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#tvf_argument. + VisitTvf_argument(ctx *Tvf_argumentContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#connection_clause. + VisitConnection_clause(ctx *Connection_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#path_expression_or_default. + VisitPath_expression_or_default(ctx *Path_expression_or_defaultContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#descriptor_argument. + VisitDescriptor_argument(ctx *Descriptor_argumentContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#descriptor_column_list. + VisitDescriptor_column_list(ctx *Descriptor_column_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#descriptor_column. + VisitDescriptor_column(ctx *Descriptor_columnContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#table_clause. + VisitTable_clause(ctx *Table_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#model_clause. + VisitModel_clause(ctx *Model_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#qualify_clause_nonreserved. + VisitQualify_clause_nonreserved(ctx *Qualify_clause_nonreservedContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#unpivot_clause. + VisitUnpivot_clause(ctx *Unpivot_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#unpivot_in_item_list. + VisitUnpivot_in_item_list(ctx *Unpivot_in_item_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#unpivot_in_item_list_prefix. + VisitUnpivot_in_item_list_prefix(ctx *Unpivot_in_item_list_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#unpivot_in_item. + VisitUnpivot_in_item(ctx *Unpivot_in_itemContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_as_string_or_integer. + VisitOpt_as_string_or_integer(ctx *Opt_as_string_or_integerContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#path_expression_list_with_opt_parens. + VisitPath_expression_list_with_opt_parens(ctx *Path_expression_list_with_opt_parensContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#path_expression_list. + VisitPath_expression_list(ctx *Path_expression_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#unpivot_nulls_filter. + VisitUnpivot_nulls_filter(ctx *Unpivot_nulls_filterContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#pivot_clause. + VisitPivot_clause(ctx *Pivot_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#pivot_expression_list. + VisitPivot_expression_list(ctx *Pivot_expression_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#pivot_expression. + VisitPivot_expression(ctx *Pivot_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#pivot_value_list. + VisitPivot_value_list(ctx *Pivot_value_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#pivot_value. + VisitPivot_value(ctx *Pivot_valueContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#tvf_prefix_no_args. + VisitTvf_prefix_no_args(ctx *Tvf_prefix_no_argsContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#join_type. + VisitJoin_type(ctx *Join_typeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_natural. + VisitOpt_natural(ctx *Opt_naturalContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#on_clause. + VisitOn_clause(ctx *On_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#select_list. + VisitSelect_list(ctx *Select_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#select_list_item. + VisitSelect_list_item(ctx *Select_list_itemContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#select_column_star. + VisitSelect_column_star(ctx *Select_column_starContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#select_column_expr. + VisitSelect_column_expr(ctx *Select_column_exprContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#select_column_dot_star. + VisitSelect_column_dot_star(ctx *Select_column_dot_starContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#star_modifiers. + VisitStar_modifiers(ctx *Star_modifiersContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#star_except_list. + VisitStar_except_list(ctx *Star_except_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#star_replace_list. + VisitStar_replace_list(ctx *Star_replace_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#star_replace_item. + VisitStar_replace_item(ctx *Star_replace_itemContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#expression. + VisitExpression(ctx *ExpressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#expression_higher_prec_than_and. + VisitExpression_higher_prec_than_and(ctx *Expression_higher_prec_than_andContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#expression_maybe_parenthesized_not_a_query. + VisitExpression_maybe_parenthesized_not_a_query(ctx *Expression_maybe_parenthesized_not_a_queryContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#parenthesized_in_rhs. + VisitParenthesized_in_rhs(ctx *Parenthesized_in_rhsContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#unary_operator. + VisitUnary_operator(ctx *Unary_operatorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#comparative_operator. + VisitComparative_operator(ctx *Comparative_operatorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#shift_operator. + VisitShift_operator(ctx *Shift_operatorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#additive_operator. + VisitAdditive_operator(ctx *Additive_operatorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#multiplicative_operator. + VisitMultiplicative_operator(ctx *Multiplicative_operatorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#is_operator. + VisitIs_operator(ctx *Is_operatorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#between_operator. + VisitBetween_operator(ctx *Between_operatorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#in_operator. + VisitIn_operator(ctx *In_operatorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#distinct_operator. + VisitDistinct_operator(ctx *Distinct_operatorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#parenthesized_query. + VisitParenthesized_query(ctx *Parenthesized_queryContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#parenthesized_expression_not_a_query. + VisitParenthesized_expression_not_a_query(ctx *Parenthesized_expression_not_a_queryContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#parenthesized_anysomeall_list_in_rhs. + VisitParenthesized_anysomeall_list_in_rhs(ctx *Parenthesized_anysomeall_list_in_rhsContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#and_expression. + VisitAnd_expression(ctx *And_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#in_list_two_or_more_prefix. + VisitIn_list_two_or_more_prefix(ctx *In_list_two_or_more_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#any_some_all. + VisitAny_some_all(ctx *Any_some_allContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#like_operator. + VisitLike_operator(ctx *Like_operatorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#expression_subquery_with_keyword. + VisitExpression_subquery_with_keyword(ctx *Expression_subquery_with_keywordContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#struct_constructor. + VisitStruct_constructor(ctx *Struct_constructorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#struct_constructor_prefix_with_keyword. + VisitStruct_constructor_prefix_with_keyword(ctx *Struct_constructor_prefix_with_keywordContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#struct_constructor_arg. + VisitStruct_constructor_arg(ctx *Struct_constructor_argContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#struct_constructor_prefix_without_keyword. + VisitStruct_constructor_prefix_without_keyword(ctx *Struct_constructor_prefix_without_keywordContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#struct_constructor_prefix_with_keyword_no_arg. + VisitStruct_constructor_prefix_with_keyword_no_arg(ctx *Struct_constructor_prefix_with_keyword_no_argContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#interval_expression. + VisitInterval_expression(ctx *Interval_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#function_call_expression_with_clauses. + VisitFunction_call_expression_with_clauses(ctx *Function_call_expression_with_clausesContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#function_call_expression_with_clauses_suffix. + VisitFunction_call_expression_with_clauses_suffix(ctx *Function_call_expression_with_clauses_suffixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#over_clause. + VisitOver_clause(ctx *Over_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#window_specification. + VisitWindow_specification(ctx *Window_specificationContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_window_frame_clause. + VisitOpt_window_frame_clause(ctx *Opt_window_frame_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#window_frame_bound. + VisitWindow_frame_bound(ctx *Window_frame_boundContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#preceding_or_following. + VisitPreceding_or_following(ctx *Preceding_or_followingContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#frame_unit. + VisitFrame_unit(ctx *Frame_unitContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#partition_by_clause. + VisitPartition_by_clause(ctx *Partition_by_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#partition_by_clause_prefix. + VisitPartition_by_clause_prefix(ctx *Partition_by_clause_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#with_group_rows. + VisitWith_group_rows(ctx *With_group_rowsContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#with_report_modifier. + VisitWith_report_modifier(ctx *With_report_modifierContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#clamped_between_modifier. + VisitClamped_between_modifier(ctx *Clamped_between_modifierContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#with_report_format. + VisitWith_report_format(ctx *With_report_formatContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#options_list. + VisitOptions_list(ctx *Options_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#options_list_prefix. + VisitOptions_list_prefix(ctx *Options_list_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#options_entry. + VisitOptions_entry(ctx *Options_entryContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#expression_or_proto. + VisitExpression_or_proto(ctx *Expression_or_protoContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#options_assignment_operator. + VisitOptions_assignment_operator(ctx *Options_assignment_operatorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_null_handling_modifier. + VisitOpt_null_handling_modifier(ctx *Opt_null_handling_modifierContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#function_call_argument. + VisitFunction_call_argument(ctx *Function_call_argumentContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#sequence_arg. + VisitSequence_arg(ctx *Sequence_argContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#named_argument. + VisitNamed_argument(ctx *Named_argumentContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#lambda_argument. + VisitLambda_argument(ctx *Lambda_argumentContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#lambda_argument_list. + VisitLambda_argument_list(ctx *Lambda_argument_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#limit_offset_clause. + VisitLimit_offset_clause(ctx *Limit_offset_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_having_or_group_by_modifier. + VisitOpt_having_or_group_by_modifier(ctx *Opt_having_or_group_by_modifierContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#group_by_clause_prefix. + VisitGroup_by_clause_prefix(ctx *Group_by_clause_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#group_by_preamble. + VisitGroup_by_preamble(ctx *Group_by_preambleContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_and_order. + VisitOpt_and_order(ctx *Opt_and_orderContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#hint. + VisitHint(ctx *HintContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#hint_with_body. + VisitHint_with_body(ctx *Hint_with_bodyContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#hint_with_body_prefix. + VisitHint_with_body_prefix(ctx *Hint_with_body_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#hint_entry. + VisitHint_entry(ctx *Hint_entryContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#identifier_in_hints. + VisitIdentifier_in_hints(ctx *Identifier_in_hintsContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#extra_identifier_in_hints_name. + VisitExtra_identifier_in_hints_name(ctx *Extra_identifier_in_hints_nameContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#grouping_item. + VisitGrouping_item(ctx *Grouping_itemContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#grouping_set_list. + VisitGrouping_set_list(ctx *Grouping_set_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#grouping_set. + VisitGrouping_set(ctx *Grouping_setContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#cube_list. + VisitCube_list(ctx *Cube_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#rollup_list. + VisitRollup_list(ctx *Rollup_listContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_as_alias_with_required_as. + VisitOpt_as_alias_with_required_as(ctx *Opt_as_alias_with_required_asContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_grouping_item_order. + VisitOpt_grouping_item_order(ctx *Opt_grouping_item_orderContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_selection_item_order. + VisitOpt_selection_item_order(ctx *Opt_selection_item_orderContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#asc_or_desc. + VisitAsc_or_desc(ctx *Asc_or_descContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#null_order. + VisitNull_order(ctx *Null_orderContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#function_name_from_keyword. + VisitFunction_name_from_keyword(ctx *Function_name_from_keywordContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#replace_fields_expression. + VisitReplace_fields_expression(ctx *Replace_fields_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#replace_fields_prefix. + VisitReplace_fields_prefix(ctx *Replace_fields_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#replace_fields_arg. + VisitReplace_fields_arg(ctx *Replace_fields_argContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#generalized_path_expression. + VisitGeneralized_path_expression(ctx *Generalized_path_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#generalized_extension_path. + VisitGeneralized_extension_path(ctx *Generalized_extension_pathContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#with_expression. + VisitWith_expression(ctx *With_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#with_expression_variable_prefix. + VisitWith_expression_variable_prefix(ctx *With_expression_variable_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#with_expression_variable. + VisitWith_expression_variable(ctx *With_expression_variableContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#extract_expression. + VisitExtract_expression(ctx *Extract_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#extract_expression_base. + VisitExtract_expression_base(ctx *Extract_expression_baseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_format. + VisitOpt_format(ctx *Opt_formatContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_at_time_zone. + VisitOpt_at_time_zone(ctx *Opt_at_time_zoneContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#cast_expression. + VisitCast_expression(ctx *Cast_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#case_expression. + VisitCase_expression(ctx *Case_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#case_expression_prefix. + VisitCase_expression_prefix(ctx *Case_expression_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#case_value_expression_prefix. + VisitCase_value_expression_prefix(ctx *Case_value_expression_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#case_no_value_expression_prefix. + VisitCase_no_value_expression_prefix(ctx *Case_no_value_expression_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#struct_braced_constructor. + VisitStruct_braced_constructor(ctx *Struct_braced_constructorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#braced_new_constructor. + VisitBraced_new_constructor(ctx *Braced_new_constructorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#braced_constructor. + VisitBraced_constructor(ctx *Braced_constructorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#braced_constructor_start. + VisitBraced_constructor_start(ctx *Braced_constructor_startContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#braced_constructor_prefix. + VisitBraced_constructor_prefix(ctx *Braced_constructor_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#braced_constructor_field. + VisitBraced_constructor_field(ctx *Braced_constructor_fieldContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#braced_constructor_lhs. + VisitBraced_constructor_lhs(ctx *Braced_constructor_lhsContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#braced_constructor_field_value. + VisitBraced_constructor_field_value(ctx *Braced_constructor_field_valueContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#braced_constructor_extension. + VisitBraced_constructor_extension(ctx *Braced_constructor_extensionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#new_constructor. + VisitNew_constructor(ctx *New_constructorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#new_constructor_prefix. + VisitNew_constructor_prefix(ctx *New_constructor_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#new_constructor_prefix_no_arg. + VisitNew_constructor_prefix_no_arg(ctx *New_constructor_prefix_no_argContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#new_constructor_arg. + VisitNew_constructor_arg(ctx *New_constructor_argContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#array_constructor. + VisitArray_constructor(ctx *Array_constructorContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#array_constructor_prefix. + VisitArray_constructor_prefix(ctx *Array_constructor_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#array_constructor_prefix_no_expressions. + VisitArray_constructor_prefix_no_expressions(ctx *Array_constructor_prefix_no_expressionsContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#range_literal. + VisitRange_literal(ctx *Range_literalContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#range_type. + VisitRange_type(ctx *Range_typeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#type. + VisitType(ctx *TypeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#collate_clause. + VisitCollate_clause(ctx *Collate_clauseContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#string_literal_or_parameter. + VisitString_literal_or_parameter(ctx *String_literal_or_parameterContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#system_variable_expression. + VisitSystem_variable_expression(ctx *System_variable_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#parameter_expression. + VisitParameter_expression(ctx *Parameter_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#named_parameter_expression. + VisitNamed_parameter_expression(ctx *Named_parameter_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#opt_type_parameters. + VisitOpt_type_parameters(ctx *Opt_type_parametersContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#type_parameters_prefix. + VisitType_parameters_prefix(ctx *Type_parameters_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#type_parameter. + VisitType_parameter(ctx *Type_parameterContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#raw_type. + VisitRaw_type(ctx *Raw_typeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#map_type. + VisitMap_type(ctx *Map_typeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#function_type. + VisitFunction_type(ctx *Function_typeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#function_type_prefix. + VisitFunction_type_prefix(ctx *Function_type_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#type_name. + VisitType_name(ctx *Type_nameContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#path_expression. + VisitPath_expression(ctx *Path_expressionContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#identifier. + VisitIdentifier(ctx *IdentifierContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#keyword_as_identifier. + VisitKeyword_as_identifier(ctx *Keyword_as_identifierContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#common_keyword_as_identifier. + VisitCommon_keyword_as_identifier(ctx *Common_keyword_as_identifierContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#token_identifier. + VisitToken_identifier(ctx *Token_identifierContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#struct_type. + VisitStruct_type(ctx *Struct_typeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#struct_type_prefix. + VisitStruct_type_prefix(ctx *Struct_type_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#struct_field. + VisitStruct_field(ctx *Struct_fieldContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#array_type. + VisitArray_type(ctx *Array_typeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#template_type_open. + VisitTemplate_type_open(ctx *Template_type_openContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#template_type_close. + VisitTemplate_type_close(ctx *Template_type_closeContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#date_or_time_literal. + VisitDate_or_time_literal(ctx *Date_or_time_literalContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#date_or_time_literal_kind. + VisitDate_or_time_literal_kind(ctx *Date_or_time_literal_kindContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#floating_point_literal. + VisitFloating_point_literal(ctx *Floating_point_literalContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#json_literal. + VisitJson_literal(ctx *Json_literalContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#bignumeric_literal. + VisitBignumeric_literal(ctx *Bignumeric_literalContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#bignumeric_literal_prefix. + VisitBignumeric_literal_prefix(ctx *Bignumeric_literal_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#numeric_literal. + VisitNumeric_literal(ctx *Numeric_literalContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#numeric_literal_prefix. + VisitNumeric_literal_prefix(ctx *Numeric_literal_prefixContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#integer_literal. + VisitInteger_literal(ctx *Integer_literalContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#bytes_literal. + VisitBytes_literal(ctx *Bytes_literalContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#null_literal. + VisitNull_literal(ctx *Null_literalContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#boolean_literal. + VisitBoolean_literal(ctx *Boolean_literalContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#string_literal. + VisitString_literal(ctx *String_literalContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#string_literal_component. + VisitString_literal_component(ctx *String_literal_componentContext) interface{} + + // Visit a parse tree produced by GoogleSQLParser#bytes_literal_component. + VisitBytes_literal_component(ctx *Bytes_literal_componentContext) interface{} +} diff --git a/googlesql/parser_test.go b/googlesql/parser_test.go new file mode 100644 index 0000000..4b6ab9a --- /dev/null +++ b/googlesql/parser_test.go @@ -0,0 +1,87 @@ +package googlesql_test + +import ( + "os" + "path" + "sort" + "testing" + + "github.com/antlr4-go/antlr/v4" + googlesql "github.com/bytebase/parser/googlesql" + "github.com/stretchr/testify/require" +) + +type CustomErrorListener struct { + errors int +} + +func NewCustomErrorListener() *CustomErrorListener { + return new(CustomErrorListener) +} + +func (l *CustomErrorListener) SyntaxError(recognizer antlr.Recognizer, offendingSymbol interface{}, line, column int, msg string, e antlr.RecognitionException) { + l.errors += 1 + antlr.ConsoleErrorListenerINSTANCE.SyntaxError(recognizer, offendingSymbol, line, column, msg, e) +} + +func (l *CustomErrorListener) ReportAmbiguity(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex int, exact bool, ambigAlts *antlr.BitSet, configs *antlr.ATNConfigSet) { + antlr.ConsoleErrorListenerINSTANCE.ReportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) +} + +func (l *CustomErrorListener) ReportAttemptingFullContext(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex int, conflictingAlts *antlr.BitSet, configs *antlr.ATNConfigSet) { + antlr.ConsoleErrorListenerINSTANCE.ReportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) +} + +func (l *CustomErrorListener) ReportContextSensitivity(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex, prediction int, configs *antlr.ATNConfigSet) { + antlr.ConsoleErrorListenerINSTANCE.ReportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs) +} + +func TestGoogleSQLParser(t *testing.T) { + testFilePaths := scanSQLFileInDirRecursive(t, "examples") + sort.StringSlice(testFilePaths).Sort() + + for _, fp := range testFilePaths { + t.Run(fp, func(t *testing.T) { + input, err := antlr.NewFileStream(fp) + require.NoError(t, err) + + lexer := googlesql.NewGoogleSQLLexer(input) + + stream := antlr.NewCommonTokenStream(lexer, 0) + p := googlesql.NewGoogleSQLParser(stream) + + lexerErrors := &CustomErrorListener{} + lexer.RemoveErrorListeners() + lexer.AddErrorListener(lexerErrors) + + parserErrors := &CustomErrorListener{} + p.RemoveErrorListeners() + p.AddErrorListener(parserErrors) + + p.BuildParseTrees = true + + _ = p.Root() + + require.Equal(t, 0, lexerErrors.errors, "file: %s", fp) + require.Equal(t, 0, parserErrors.errors, "file: %s", fp) + }) + } +} + +func scanSQLFileInDirRecursive(t *testing.T, dir string) []string { + var fps []string + + files, err := os.ReadDir(dir) + require.NoError(t, err) + + for _, file := range files { + if file.IsDir() { + rfps := scanSQLFileInDirRecursive(t, path.Join(dir, file.Name())) + fps = append(fps, rfps...) + } else { + fps = append(fps, path.Join(dir, file.Name())) + } + } + + return fps +}