github.com/iasthc/atlas/cmd/atlas@v0.0.0-20230523071841-73246df3f88d/internal/sqlparse/sqliteparse/parser.go (about) 1 // Code generated from Parser.g4 by ANTLR 4.10.1. DO NOT EDIT. 2 3 package sqliteparse // Parser 4 import ( 5 "fmt" 6 "strconv" 7 "sync" 8 9 "github.com/antlr/antlr4/runtime/Go/antlr" 10 ) 11 12 // Suppress unused import errors 13 var _ = fmt.Printf 14 var _ = strconv.Itoa 15 var _ = sync.Once{} 16 17 type Parser struct { 18 *antlr.BaseParser 19 } 20 21 var parserParserStaticData struct { 22 once sync.Once 23 serializedATN []int32 24 literalNames []string 25 symbolicNames []string 26 ruleNames []string 27 predictionContextCache *antlr.PredictionContextCache 28 atn *antlr.ATN 29 decisionToDFA []*antlr.DFA 30 } 31 32 func parserParserInit() { 33 staticData := &parserParserStaticData 34 staticData.literalNames = []string{ 35 "", "';'", "'.'", "'('", "')'", "','", "'='", "'*'", "'+'", "'-'", "'~'", 36 "'||'", "'/'", "'%'", "'<<'", "'>>'", "'&'", "'|'", "'<'", "'<='", "'>'", 37 "'>='", "'=='", "'!='", "'<>'", "'ABORT'", "'ACTION'", "'ADD'", "'AFTER'", 38 "'ALL'", "'ALTER'", "'ANALYZE'", "'AND'", "'AS'", "'ASC'", "'ATTACH'", 39 "'AUTOINCREMENT'", "'BEFORE'", "'BEGIN'", "'BETWEEN'", "'BY'", "'CASCADE'", 40 "'CASE'", "'CAST'", "'CHECK'", "'COLLATE'", "'COLUMN'", "'COMMIT'", 41 "'CONFLICT'", "'CONSTRAINT'", "'CREATE'", "'CROSS'", "'CURRENT_DATE'", 42 "'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", "'DATABASE'", "'DEFAULT'", 43 "'DEFERRABLE'", "'DEFERRED'", "'DELETE'", "'DESC'", "'DETACH'", "'DISTINCT'", 44 "'DROP'", "'EACH'", "'ELSE'", "'END'", "'ESCAPE'", "'EXCEPT'", "'EXCLUSIVE'", 45 "'EXISTS'", "'EXPLAIN'", "'FAIL'", "'FOR'", "'FOREIGN'", "'FROM'", "'FULL'", 46 "'GLOB'", "'GROUP'", "'HAVING'", "'IF'", "'IGNORE'", "'IMMEDIATE'", 47 "'IN'", "'INDEX'", "'INDEXED'", "'INITIALLY'", "'INNER'", "'INSERT'", 48 "'INSTEAD'", "'INTERSECT'", "'INTO'", "'IS'", "'ISNULL'", "'JOIN'", 49 "'KEY'", "'LEFT'", "'LIKE'", "'LIMIT'", "'MATCH'", "'NATURAL'", "'NO'", 50 "'NOT'", "'NOTNULL'", "'NULL'", "'OF'", "'OFFSET'", "'ON'", "'OR'", 51 "'ORDER'", "'OUTER'", "'PLAN'", "'PRAGMA'", "'PRIMARY'", "'QUERY'", 52 "'RAISE'", "'RECURSIVE'", "'REFERENCES'", "'REGEXP'", "'REINDEX'", "'RELEASE'", 53 "'RENAME'", "'REPLACE'", "'RESTRICT'", "'RETURNING'", "'RIGHT'", "'ROLLBACK'", 54 "'ROW'", "'ROWS'", "'SAVEPOINT'", "'SELECT'", "'SET'", "'TABLE'", "'TEMP'", 55 "'TEMPORARY'", "'THEN'", "'TO'", "'TRANSACTION'", "'TRIGGER'", "'UNION'", 56 "'UNIQUE'", "'UPDATE'", "'USING'", "'VACUUM'", "'VALUES'", "'VIEW'", 57 "'VIRTUAL'", "'WHEN'", "'WHERE'", "'WITH'", "'WITHOUT'", "'FIRST_VALUE'", 58 "'OVER'", "'PARTITION'", "'RANGE'", "'PRECEDING'", "'UNBOUNDED'", "'CURRENT'", 59 "'FOLLOWING'", "'CUME_DIST'", "'DENSE_RANK'", "'LAG'", "'LAST_VALUE'", 60 "'LEAD'", "'NTH_VALUE'", "'NTILE'", "'PERCENT_RANK'", "'RANK'", "'ROW_NUMBER'", 61 "'GENERATED'", "'ALWAYS'", "'STORED'", "'TRUE'", "'FALSE'", "'WINDOW'", 62 "'NULLS'", "'FIRST'", "'LAST'", "'FILTER'", "'GROUPS'", "'EXCLUDE'", 63 "'TIES'", "'OTHERS'", "'DO'", "'NOTHING'", 64 } 65 staticData.symbolicNames = []string{ 66 "", "SCOL", "DOT", "OPEN_PAR", "CLOSE_PAR", "COMMA", "ASSIGN", "STAR", 67 "PLUS", "MINUS", "TILDE", "PIPE2", "DIV", "MOD", "LT2", "GT2", "AMP", 68 "PIPE", "LT", "LT_EQ", "GT", "GT_EQ", "EQ", "NOT_EQ1", "NOT_EQ2", "ABORT_", 69 "ACTION_", "ADD_", "AFTER_", "ALL_", "ALTER_", "ANALYZE_", "AND_", "AS_", 70 "ASC_", "ATTACH_", "AUTOINCREMENT_", "BEFORE_", "BEGIN_", "BETWEEN_", 71 "BY_", "CASCADE_", "CASE_", "CAST_", "CHECK_", "COLLATE_", "COLUMN_", 72 "COMMIT_", "CONFLICT_", "CONSTRAINT_", "CREATE_", "CROSS_", "CURRENT_DATE_", 73 "CURRENT_TIME_", "CURRENT_TIMESTAMP_", "DATABASE_", "DEFAULT_", "DEFERRABLE_", 74 "DEFERRED_", "DELETE_", "DESC_", "DETACH_", "DISTINCT_", "DROP_", "EACH_", 75 "ELSE_", "END_", "ESCAPE_", "EXCEPT_", "EXCLUSIVE_", "EXISTS_", "EXPLAIN_", 76 "FAIL_", "FOR_", "FOREIGN_", "FROM_", "FULL_", "GLOB_", "GROUP_", "HAVING_", 77 "IF_", "IGNORE_", "IMMEDIATE_", "IN_", "INDEX_", "INDEXED_", "INITIALLY_", 78 "INNER_", "INSERT_", "INSTEAD_", "INTERSECT_", "INTO_", "IS_", "ISNULL_", 79 "JOIN_", "KEY_", "LEFT_", "LIKE_", "LIMIT_", "MATCH_", "NATURAL_", "NO_", 80 "NOT_", "NOTNULL_", "NULL_", "OF_", "OFFSET_", "ON_", "OR_", "ORDER_", 81 "OUTER_", "PLAN_", "PRAGMA_", "PRIMARY_", "QUERY_", "RAISE_", "RECURSIVE_", 82 "REFERENCES_", "REGEXP_", "REINDEX_", "RELEASE_", "RENAME_", "REPLACE_", 83 "RESTRICT_", "RETURNING_", "RIGHT_", "ROLLBACK_", "ROW_", "ROWS_", "SAVEPOINT_", 84 "SELECT_", "SET_", "TABLE_", "TEMP_", "TEMPORARY_", "THEN_", "TO_", 85 "TRANSACTION_", "TRIGGER_", "UNION_", "UNIQUE_", "UPDATE_", "USING_", 86 "VACUUM_", "VALUES_", "VIEW_", "VIRTUAL_", "WHEN_", "WHERE_", "WITH_", 87 "WITHOUT_", "FIRST_VALUE_", "OVER_", "PARTITION_", "RANGE_", "PRECEDING_", 88 "UNBOUNDED_", "CURRENT_", "FOLLOWING_", "CUME_DIST_", "DENSE_RANK_", 89 "LAG_", "LAST_VALUE_", "LEAD_", "NTH_VALUE_", "NTILE_", "PERCENT_RANK_", 90 "RANK_", "ROW_NUMBER_", "GENERATED_", "ALWAYS_", "STORED_", "TRUE_", 91 "FALSE_", "WINDOW_", "NULLS_", "FIRST_", "LAST_", "FILTER_", "GROUPS_", 92 "EXCLUDE_", "TIES_", "OTHERS_", "DO_", "NOTHING_", "IDENTIFIER", "NUMERIC_LITERAL", 93 "BIND_PARAMETER", "STRING_LITERAL", "BLOB_LITERAL", "SINGLE_LINE_COMMENT", 94 "MULTILINE_COMMENT", "SPACES", "UNEXPECTED_CHAR", 95 } 96 staticData.ruleNames = []string{ 97 "parse", "sql_stmt_list", "sql_stmt", "alter_table_stmt", "analyze_stmt", 98 "attach_stmt", "begin_stmt", "commit_stmt", "rollback_stmt", "savepoint_stmt", 99 "release_stmt", "create_index_stmt", "indexed_column", "create_table_stmt", 100 "column_def", "type_name", "column_constraint", "signed_number", "table_constraint", 101 "foreign_key_clause", "conflict_clause", "create_trigger_stmt", "create_view_stmt", 102 "create_virtual_table_stmt", "with_clause", "cte_table_name", "recursive_cte", 103 "common_table_expression", "delete_stmt", "delete_stmt_limited", "detach_stmt", 104 "drop_stmt", "expr", "raise_function", "literal_value", "insert_stmt", 105 "returning_clause", "upsert_clause", "pragma_stmt", "pragma_value", 106 "reindex_stmt", "select_stmt", "join_clause", "select_core", "factored_select_stmt", 107 "simple_select_stmt", "compound_select_stmt", "table_or_subquery", "result_column", 108 "join_operator", "join_constraint", "compound_operator", "update_stmt", 109 "assignment_list", "assignment", "column_name_list", "update_stmt_limited", 110 "qualified_table_name", "vacuum_stmt", "filter_clause", "window_defn", 111 "over_clause", "frame_spec", "frame_clause", "simple_function_invocation", 112 "aggregate_function_invocation", "window_function_invocation", "common_table_stmt", 113 "order_by_stmt", "limit_stmt", "ordering_term", "asc_desc", "frame_left", 114 "frame_right", "frame_single", "window_function", "offset", "default_value", 115 "partition_by", "order_by_expr", "order_by_expr_asc_desc", "expr_asc_desc", 116 "initial_select", "recursive_select", "unary_operator", "error_message", 117 "module_argument", "column_alias", "keyword", "name", "function_name", 118 "schema_name", "table_name", "table_or_index_name", "column_name", "collation_name", 119 "foreign_table", "index_name", "trigger_name", "view_name", "module_name", 120 "pragma_name", "savepoint_name", "table_alias", "transaction_name", 121 "window_name", "alias", "filename", "base_window_name", "simple_func", 122 "aggregate_func", "table_function_name", "any_name", 123 } 124 staticData.predictionContextCache = antlr.NewPredictionContextCache() 125 staticData.serializedATN = []int32{ 126 4, 1, 193, 2083, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 127 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 128 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 129 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 130 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 131 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 132 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 133 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 134 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 135 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 136 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 137 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 138 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 139 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 140 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 141 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 142 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 143 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 144 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 145 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 146 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 147 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 1, 148 0, 5, 0, 228, 8, 0, 10, 0, 12, 0, 231, 9, 0, 1, 0, 1, 0, 1, 1, 5, 1, 236, 149 8, 1, 10, 1, 12, 1, 239, 9, 1, 1, 1, 1, 1, 4, 1, 243, 8, 1, 11, 1, 12, 150 1, 244, 1, 1, 5, 1, 248, 8, 1, 10, 1, 12, 1, 251, 9, 1, 1, 1, 5, 1, 254, 151 8, 1, 10, 1, 12, 1, 257, 9, 1, 1, 2, 1, 2, 1, 2, 3, 2, 262, 8, 2, 3, 2, 152 264, 8, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 153 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 154 1, 2, 1, 2, 3, 2, 290, 8, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 297, 8, 155 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 304, 8, 3, 1, 3, 1, 3, 1, 3, 1, 156 3, 3, 3, 310, 8, 3, 1, 3, 1, 3, 3, 3, 314, 8, 3, 1, 3, 1, 3, 1, 3, 3, 3, 157 319, 8, 3, 1, 3, 3, 3, 322, 8, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 329, 158 8, 4, 1, 4, 3, 4, 332, 8, 4, 1, 5, 1, 5, 3, 5, 336, 8, 5, 1, 5, 1, 5, 1, 159 5, 1, 5, 1, 6, 1, 6, 3, 6, 344, 8, 6, 1, 6, 1, 6, 3, 6, 348, 8, 6, 3, 6, 160 350, 8, 6, 1, 7, 1, 7, 3, 7, 354, 8, 7, 1, 8, 1, 8, 3, 8, 358, 8, 8, 1, 161 8, 1, 8, 3, 8, 362, 8, 8, 1, 8, 3, 8, 365, 8, 8, 1, 9, 1, 9, 1, 9, 1, 10, 162 1, 10, 3, 10, 372, 8, 10, 1, 10, 1, 10, 1, 11, 1, 11, 3, 11, 378, 8, 11, 163 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 384, 8, 11, 1, 11, 1, 11, 1, 11, 3, 164 11, 389, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 5, 11, 165 398, 8, 11, 10, 11, 12, 11, 401, 9, 11, 1, 11, 1, 11, 1, 11, 3, 11, 406, 166 8, 11, 1, 12, 1, 12, 3, 12, 410, 8, 12, 1, 12, 1, 12, 3, 12, 414, 8, 12, 167 1, 12, 3, 12, 417, 8, 12, 1, 13, 1, 13, 3, 13, 421, 8, 13, 1, 13, 1, 13, 168 1, 13, 1, 13, 3, 13, 427, 8, 13, 1, 13, 1, 13, 1, 13, 3, 13, 432, 8, 13, 169 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 5, 13, 439, 8, 13, 10, 13, 12, 13, 442, 170 9, 13, 1, 13, 1, 13, 5, 13, 446, 8, 13, 10, 13, 12, 13, 449, 9, 13, 1, 171 13, 1, 13, 1, 13, 3, 13, 454, 8, 13, 1, 13, 1, 13, 3, 13, 458, 8, 13, 1, 172 14, 1, 14, 3, 14, 462, 8, 14, 1, 14, 5, 14, 465, 8, 14, 10, 14, 12, 14, 173 468, 9, 14, 1, 15, 4, 15, 471, 8, 15, 11, 15, 12, 15, 472, 1, 15, 1, 15, 174 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 485, 8, 175 15, 1, 16, 1, 16, 3, 16, 489, 8, 16, 1, 16, 1, 16, 1, 16, 3, 16, 494, 8, 176 16, 1, 16, 3, 16, 497, 8, 16, 1, 16, 3, 16, 500, 8, 16, 1, 16, 1, 16, 1, 177 16, 3, 16, 505, 8, 16, 1, 16, 3, 16, 508, 8, 16, 1, 16, 1, 16, 1, 16, 1, 178 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 522, 179 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 529, 8, 16, 1, 16, 1, 180 16, 1, 16, 1, 16, 1, 16, 3, 16, 536, 8, 16, 3, 16, 538, 8, 16, 1, 17, 3, 181 17, 541, 8, 17, 1, 17, 1, 17, 1, 18, 1, 18, 3, 18, 547, 8, 18, 1, 18, 1, 182 18, 1, 18, 3, 18, 552, 8, 18, 1, 18, 1, 18, 1, 18, 1, 18, 5, 18, 558, 8, 183 18, 10, 18, 12, 18, 561, 9, 18, 1, 18, 1, 18, 3, 18, 565, 8, 18, 1, 18, 184 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 5, 185 18, 578, 8, 18, 10, 18, 12, 18, 581, 9, 18, 1, 18, 1, 18, 1, 18, 3, 18, 186 586, 8, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 5, 19, 594, 8, 19, 187 10, 19, 12, 19, 597, 9, 19, 1, 19, 1, 19, 3, 19, 601, 8, 19, 1, 19, 1, 188 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 611, 8, 19, 1, 19, 189 1, 19, 5, 19, 615, 8, 19, 10, 19, 12, 19, 618, 9, 19, 1, 19, 3, 19, 621, 190 8, 19, 1, 19, 1, 19, 1, 19, 3, 19, 626, 8, 19, 3, 19, 628, 8, 19, 1, 20, 191 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 3, 21, 636, 8, 21, 1, 21, 1, 21, 1, 192 21, 1, 21, 3, 21, 642, 8, 21, 1, 21, 1, 21, 1, 21, 3, 21, 647, 8, 21, 1, 193 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 654, 8, 21, 1, 21, 1, 21, 1, 21, 194 1, 21, 1, 21, 1, 21, 1, 21, 5, 21, 663, 8, 21, 10, 21, 12, 21, 666, 9, 195 21, 3, 21, 668, 8, 21, 3, 21, 670, 8, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 196 21, 3, 21, 677, 8, 21, 1, 21, 1, 21, 3, 21, 681, 8, 21, 1, 21, 1, 21, 1, 197 21, 1, 21, 1, 21, 3, 21, 688, 8, 21, 1, 21, 1, 21, 4, 21, 692, 8, 21, 11, 198 21, 12, 21, 693, 1, 21, 1, 21, 1, 22, 1, 22, 3, 22, 700, 8, 22, 1, 22, 199 1, 22, 1, 22, 1, 22, 3, 22, 706, 8, 22, 1, 22, 1, 22, 1, 22, 3, 22, 711, 200 8, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 5, 22, 718, 8, 22, 10, 22, 12, 201 22, 721, 9, 22, 1, 22, 1, 22, 3, 22, 725, 8, 22, 1, 22, 1, 22, 1, 22, 1, 202 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 3, 23, 736, 8, 23, 1, 23, 1, 23, 203 1, 23, 3, 23, 741, 8, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 204 23, 5, 23, 750, 8, 23, 10, 23, 12, 23, 753, 9, 23, 1, 23, 1, 23, 3, 23, 205 757, 8, 23, 1, 24, 1, 24, 3, 24, 761, 8, 24, 1, 24, 1, 24, 1, 24, 1, 24, 206 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 5, 24, 775, 8, 207 24, 10, 24, 12, 24, 778, 9, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 5, 25, 208 785, 8, 25, 10, 25, 12, 25, 788, 9, 25, 1, 25, 1, 25, 3, 25, 792, 8, 25, 209 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 3, 26, 800, 8, 26, 1, 26, 1, 210 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 5, 27, 810, 8, 27, 10, 27, 211 12, 27, 813, 9, 27, 1, 27, 1, 27, 3, 27, 817, 8, 27, 1, 27, 1, 27, 1, 27, 212 1, 27, 1, 27, 1, 28, 3, 28, 825, 8, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 213 28, 3, 28, 832, 8, 28, 1, 28, 3, 28, 835, 8, 28, 1, 29, 3, 29, 838, 8, 214 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 3, 29, 845, 8, 29, 1, 29, 3, 29, 215 848, 8, 29, 1, 29, 3, 29, 851, 8, 29, 1, 29, 3, 29, 854, 8, 29, 1, 30, 216 1, 30, 3, 30, 858, 8, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 3, 217 31, 866, 8, 31, 1, 31, 1, 31, 1, 31, 3, 31, 871, 8, 31, 1, 31, 1, 31, 1, 218 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 881, 8, 32, 1, 32, 1, 32, 219 1, 32, 3, 32, 886, 8, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 220 32, 3, 32, 895, 8, 32, 1, 32, 1, 32, 1, 32, 5, 32, 900, 8, 32, 10, 32, 221 12, 32, 903, 9, 32, 1, 32, 3, 32, 906, 8, 32, 1, 32, 1, 32, 3, 32, 910, 222 8, 32, 1, 32, 3, 32, 913, 8, 32, 1, 32, 1, 32, 1, 32, 1, 32, 5, 32, 919, 223 8, 32, 10, 32, 12, 32, 922, 9, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 224 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 934, 8, 32, 1, 32, 3, 32, 937, 8, 225 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 945, 8, 32, 1, 32, 226 1, 32, 1, 32, 1, 32, 1, 32, 4, 32, 952, 8, 32, 11, 32, 12, 32, 953, 1, 227 32, 1, 32, 3, 32, 958, 8, 32, 1, 32, 1, 32, 1, 32, 3, 32, 963, 8, 32, 1, 228 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 229 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 230 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 993, 8, 32, 1, 32, 231 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 1005, 232 8, 32, 1, 32, 1, 32, 1, 32, 3, 32, 1010, 8, 32, 1, 32, 1, 32, 1, 32, 1, 233 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 1022, 8, 32, 1, 32, 234 1, 32, 1, 32, 1, 32, 3, 32, 1028, 8, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 235 32, 3, 32, 1035, 8, 32, 1, 32, 1, 32, 3, 32, 1039, 8, 32, 1, 32, 1, 32, 236 1, 32, 1, 32, 1, 32, 1, 32, 5, 32, 1047, 8, 32, 10, 32, 12, 32, 1050, 9, 237 32, 3, 32, 1052, 8, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 1058, 8, 32, 238 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 1064, 8, 32, 1, 32, 1, 32, 1, 32, 1, 239 32, 1, 32, 5, 32, 1071, 8, 32, 10, 32, 12, 32, 1074, 9, 32, 3, 32, 1076, 240 8, 32, 1, 32, 1, 32, 3, 32, 1080, 8, 32, 5, 32, 1082, 8, 32, 10, 32, 12, 241 32, 1085, 9, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 1093, 242 8, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 35, 3, 35, 1100, 8, 35, 1, 35, 1, 243 35, 1, 35, 1, 35, 1, 35, 3, 35, 1107, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 244 3, 35, 1113, 8, 35, 1, 35, 1, 35, 1, 35, 3, 35, 1118, 8, 35, 1, 35, 1, 245 35, 1, 35, 1, 35, 5, 35, 1124, 8, 35, 10, 35, 12, 35, 1127, 9, 35, 1, 35, 246 1, 35, 3, 35, 1131, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 5, 35, 1138, 247 8, 35, 10, 35, 12, 35, 1141, 9, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 248 1, 35, 5, 35, 1149, 8, 35, 10, 35, 12, 35, 1152, 9, 35, 1, 35, 1, 35, 5, 249 35, 1156, 8, 35, 10, 35, 12, 35, 1159, 9, 35, 1, 35, 3, 35, 1162, 8, 35, 250 1, 35, 3, 35, 1165, 8, 35, 1, 35, 1, 35, 3, 35, 1169, 8, 35, 1, 35, 3, 251 35, 1172, 8, 35, 1, 36, 1, 36, 1, 36, 1, 36, 5, 36, 1178, 8, 36, 10, 36, 252 12, 36, 1181, 9, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 5, 37, 1189, 253 8, 37, 10, 37, 12, 37, 1192, 9, 37, 1, 37, 1, 37, 1, 37, 3, 37, 1197, 8, 254 37, 3, 37, 1199, 8, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 3, 37, 255 1207, 8, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 3, 37, 1214, 8, 37, 1, 256 37, 1, 37, 1, 37, 5, 37, 1219, 8, 37, 10, 37, 12, 37, 1222, 9, 37, 1, 37, 257 1, 37, 3, 37, 1226, 8, 37, 3, 37, 1228, 8, 37, 1, 38, 1, 38, 1, 38, 1, 258 38, 3, 38, 1234, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 259 3, 38, 1243, 8, 38, 1, 39, 1, 39, 1, 39, 3, 39, 1248, 8, 39, 1, 40, 1, 260 40, 1, 40, 1, 40, 1, 40, 3, 40, 1255, 8, 40, 1, 40, 1, 40, 3, 40, 1259, 261 8, 40, 3, 40, 1261, 8, 40, 1, 41, 3, 41, 1264, 8, 41, 1, 41, 1, 41, 1, 262 41, 1, 41, 5, 41, 1270, 8, 41, 10, 41, 12, 41, 1273, 9, 41, 1, 41, 3, 41, 263 1276, 8, 41, 1, 41, 3, 41, 1279, 8, 41, 1, 42, 1, 42, 1, 42, 1, 42, 3, 264 42, 1285, 8, 42, 5, 42, 1287, 8, 42, 10, 42, 12, 42, 1290, 9, 42, 1, 43, 265 1, 43, 3, 43, 1294, 8, 43, 1, 43, 1, 43, 1, 43, 5, 43, 1299, 8, 43, 10, 266 43, 12, 43, 1302, 9, 43, 1, 43, 1, 43, 1, 43, 1, 43, 5, 43, 1308, 8, 43, 267 10, 43, 12, 43, 1311, 9, 43, 1, 43, 3, 43, 1314, 8, 43, 3, 43, 1316, 8, 268 43, 1, 43, 1, 43, 3, 43, 1320, 8, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 269 5, 43, 1327, 8, 43, 10, 43, 12, 43, 1330, 9, 43, 1, 43, 1, 43, 3, 43, 1334, 270 8, 43, 3, 43, 1336, 8, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 271 43, 1, 43, 1, 43, 5, 43, 1347, 8, 43, 10, 43, 12, 43, 1350, 9, 43, 3, 43, 272 1352, 8, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 5, 43, 1359, 8, 43, 10, 273 43, 12, 43, 1362, 9, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 5, 43, 274 1370, 8, 43, 10, 43, 12, 43, 1373, 9, 43, 1, 43, 1, 43, 5, 43, 1377, 8, 275 43, 10, 43, 12, 43, 1380, 9, 43, 3, 43, 1382, 8, 43, 1, 44, 1, 44, 1, 45, 276 3, 45, 1387, 8, 45, 1, 45, 1, 45, 3, 45, 1391, 8, 45, 1, 45, 3, 45, 1394, 277 8, 45, 1, 46, 3, 46, 1397, 8, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1402, 8, 278 46, 1, 46, 1, 46, 3, 46, 1406, 8, 46, 1, 46, 4, 46, 1409, 8, 46, 11, 46, 279 12, 46, 1410, 1, 46, 3, 46, 1414, 8, 46, 1, 46, 3, 46, 1417, 8, 46, 1, 280 47, 1, 47, 1, 47, 3, 47, 1422, 8, 47, 1, 47, 1, 47, 3, 47, 1426, 8, 47, 281 1, 47, 3, 47, 1429, 8, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 3, 47, 1436, 282 8, 47, 1, 47, 1, 47, 1, 47, 3, 47, 1441, 8, 47, 1, 47, 1, 47, 1, 47, 1, 283 47, 1, 47, 5, 47, 1448, 8, 47, 10, 47, 12, 47, 1451, 9, 47, 1, 47, 1, 47, 284 3, 47, 1455, 8, 47, 1, 47, 3, 47, 1458, 8, 47, 1, 47, 1, 47, 1, 47, 1, 285 47, 5, 47, 1464, 8, 47, 10, 47, 12, 47, 1467, 9, 47, 1, 47, 3, 47, 1470, 286 8, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 3, 47, 1478, 8, 47, 1, 287 47, 3, 47, 1481, 8, 47, 3, 47, 1483, 8, 47, 1, 48, 1, 48, 1, 48, 1, 48, 288 1, 48, 1, 48, 1, 48, 3, 48, 1492, 8, 48, 1, 48, 3, 48, 1495, 8, 48, 3, 289 48, 1497, 8, 48, 1, 49, 1, 49, 3, 49, 1501, 8, 49, 1, 49, 1, 49, 3, 49, 290 1505, 8, 49, 1, 49, 1, 49, 3, 49, 1509, 8, 49, 1, 49, 3, 49, 1512, 8, 49, 291 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 5, 50, 1521, 8, 50, 10, 292 50, 12, 50, 1524, 9, 50, 1, 50, 1, 50, 3, 50, 1528, 8, 50, 1, 51, 1, 51, 293 3, 51, 1532, 8, 51, 1, 51, 1, 51, 3, 51, 1536, 8, 51, 1, 52, 3, 52, 1539, 294 8, 52, 1, 52, 1, 52, 1, 52, 3, 52, 1544, 8, 52, 1, 52, 1, 52, 1, 52, 1, 295 52, 1, 52, 1, 52, 1, 52, 5, 52, 1553, 8, 52, 10, 52, 12, 52, 1556, 9, 52, 296 1, 52, 3, 52, 1559, 8, 52, 3, 52, 1561, 8, 52, 1, 52, 1, 52, 3, 52, 1565, 297 8, 52, 1, 52, 3, 52, 1568, 8, 52, 1, 53, 1, 53, 1, 53, 5, 53, 1573, 8, 298 53, 10, 53, 12, 53, 1576, 9, 53, 1, 54, 1, 54, 3, 54, 1580, 8, 54, 1, 54, 299 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1589, 8, 55, 10, 55, 12, 300 55, 1592, 9, 55, 1, 55, 1, 55, 1, 56, 3, 56, 1597, 8, 56, 1, 56, 1, 56, 301 1, 56, 3, 56, 1602, 8, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1608, 8, 302 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1615, 8, 56, 1, 56, 1, 56, 303 1, 56, 5, 56, 1620, 8, 56, 10, 56, 12, 56, 1623, 9, 56, 1, 56, 1, 56, 3, 304 56, 1627, 8, 56, 1, 56, 3, 56, 1630, 8, 56, 1, 56, 3, 56, 1633, 8, 56, 305 1, 56, 3, 56, 1636, 8, 56, 1, 57, 1, 57, 1, 57, 3, 57, 1641, 8, 57, 1, 306 57, 1, 57, 1, 57, 3, 57, 1646, 8, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 307 3, 57, 1653, 8, 57, 1, 58, 1, 58, 3, 58, 1657, 8, 58, 1, 58, 1, 58, 3, 308 58, 1661, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 309 3, 60, 1671, 8, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 5, 60, 1678, 8, 310 60, 10, 60, 12, 60, 1681, 9, 60, 3, 60, 1683, 8, 60, 1, 60, 1, 60, 1, 60, 311 1, 60, 1, 60, 5, 60, 1690, 8, 60, 10, 60, 12, 60, 1693, 9, 60, 1, 60, 3, 312 60, 1696, 8, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1704, 313 8, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 5, 61, 1711, 8, 61, 10, 61, 12, 314 61, 1714, 9, 61, 3, 61, 1716, 8, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 315 5, 61, 1723, 8, 61, 10, 61, 12, 61, 1726, 9, 61, 3, 61, 1728, 8, 61, 1, 316 61, 3, 61, 1731, 8, 61, 1, 61, 3, 61, 1734, 8, 61, 1, 62, 1, 62, 1, 62, 317 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 3, 62, 1744, 8, 62, 1, 63, 1, 63, 1, 318 63, 1, 63, 1, 63, 1, 63, 1, 63, 3, 63, 1753, 8, 63, 1, 64, 1, 64, 1, 64, 319 1, 64, 1, 64, 5, 64, 1760, 8, 64, 10, 64, 12, 64, 1763, 9, 64, 1, 64, 3, 320 64, 1766, 8, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 3, 65, 1773, 8, 65, 321 1, 65, 1, 65, 1, 65, 5, 65, 1778, 8, 65, 10, 65, 12, 65, 1781, 9, 65, 1, 322 65, 3, 65, 1784, 8, 65, 1, 65, 1, 65, 3, 65, 1788, 8, 65, 1, 66, 1, 66, 323 1, 66, 1, 66, 1, 66, 5, 66, 1795, 8, 66, 10, 66, 12, 66, 1798, 9, 66, 1, 324 66, 3, 66, 1801, 8, 66, 1, 66, 1, 66, 3, 66, 1805, 8, 66, 1, 66, 1, 66, 325 1, 66, 3, 66, 1810, 8, 66, 1, 67, 1, 67, 3, 67, 1814, 8, 67, 1, 67, 1, 326 67, 1, 67, 5, 67, 1819, 8, 67, 10, 67, 12, 67, 1822, 9, 67, 1, 68, 1, 68, 327 1, 68, 1, 68, 1, 68, 5, 68, 1829, 8, 68, 10, 68, 12, 68, 1832, 9, 68, 1, 328 69, 1, 69, 1, 69, 1, 69, 3, 69, 1838, 8, 69, 1, 70, 1, 70, 1, 70, 3, 70, 329 1843, 8, 70, 1, 70, 3, 70, 1846, 8, 70, 1, 70, 1, 70, 3, 70, 1850, 8, 70, 330 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 331 72, 1, 72, 3, 72, 1864, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 332 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1876, 8, 73, 1, 74, 1, 74, 1, 74, 1, 333 74, 1, 74, 1, 74, 1, 74, 3, 74, 1885, 8, 74, 1, 75, 1, 75, 1, 75, 1, 75, 334 1, 75, 1, 75, 1, 75, 3, 75, 1894, 8, 75, 1, 75, 1, 75, 3, 75, 1898, 8, 335 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1908, 336 8, 75, 1, 75, 3, 75, 1911, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 337 75, 1, 75, 3, 75, 1920, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 338 1, 75, 3, 75, 1929, 8, 75, 1, 75, 3, 75, 1932, 8, 75, 1, 75, 1, 75, 1, 339 75, 1, 75, 3, 75, 1938, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 340 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1952, 8, 75, 1, 75, 1, 341 75, 3, 75, 1956, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 342 1, 75, 1, 75, 3, 75, 1967, 8, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1972, 8, 343 75, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 4, 78, 344 1983, 8, 78, 11, 78, 12, 78, 1984, 1, 79, 1, 79, 1, 79, 4, 79, 1990, 8, 345 79, 11, 79, 12, 79, 1991, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 3, 346 81, 2000, 8, 81, 1, 81, 1, 81, 1, 81, 3, 81, 2005, 8, 81, 5, 81, 2007, 347 8, 81, 10, 81, 12, 81, 2010, 9, 81, 1, 82, 1, 82, 1, 83, 1, 83, 1, 84, 348 1, 84, 1, 85, 1, 85, 1, 86, 1, 86, 3, 86, 2022, 8, 86, 1, 87, 1, 87, 1, 349 88, 1, 88, 1, 89, 1, 89, 1, 90, 1, 90, 1, 91, 1, 91, 1, 92, 1, 92, 1, 93, 350 1, 93, 1, 94, 1, 94, 1, 95, 1, 95, 1, 96, 1, 96, 1, 97, 1, 97, 1, 98, 1, 351 98, 1, 99, 1, 99, 1, 100, 1, 100, 1, 101, 1, 101, 1, 102, 1, 102, 1, 103, 352 1, 103, 1, 104, 1, 104, 1, 105, 1, 105, 1, 106, 1, 106, 1, 107, 1, 107, 353 1, 108, 1, 108, 1, 109, 1, 109, 1, 110, 1, 110, 1, 111, 1, 111, 1, 112, 354 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 2081, 8, 112, 1, 355 112, 2, 440, 472, 1, 64, 113, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 356 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 357 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 358 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 359 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 360 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 361 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 362 216, 218, 220, 222, 224, 0, 28, 3, 0, 58, 58, 69, 69, 82, 82, 2, 0, 47, 363 47, 66, 66, 1, 0, 133, 134, 2, 0, 146, 146, 171, 171, 1, 0, 8, 9, 2, 0, 364 59, 59, 141, 141, 2, 0, 56, 56, 104, 104, 2, 0, 58, 58, 82, 82, 5, 0, 25, 365 25, 72, 72, 81, 81, 122, 122, 126, 126, 4, 0, 84, 84, 132, 132, 138, 138, 366 145, 145, 2, 0, 7, 7, 12, 13, 1, 0, 14, 17, 1, 0, 18, 21, 4, 0, 77, 77, 367 97, 97, 99, 99, 118, 118, 3, 0, 25, 25, 72, 72, 126, 126, 5, 0, 52, 54, 368 104, 104, 172, 173, 186, 186, 188, 189, 2, 0, 29, 29, 62, 62, 3, 0, 128, 369 128, 154, 154, 179, 179, 2, 0, 5, 5, 106, 106, 1, 0, 176, 177, 2, 0, 34, 370 34, 60, 60, 2, 0, 151, 151, 162, 162, 2, 0, 159, 159, 166, 166, 2, 0, 160, 371 160, 167, 168, 2, 0, 161, 161, 163, 163, 2, 0, 8, 10, 102, 102, 2, 0, 185, 372 185, 188, 188, 2, 0, 25, 123, 125, 180, 2367, 0, 229, 1, 0, 0, 0, 2, 237, 373 1, 0, 0, 0, 4, 263, 1, 0, 0, 0, 6, 291, 1, 0, 0, 0, 8, 323, 1, 0, 0, 0, 374 10, 333, 1, 0, 0, 0, 12, 341, 1, 0, 0, 0, 14, 351, 1, 0, 0, 0, 16, 355, 375 1, 0, 0, 0, 18, 366, 1, 0, 0, 0, 20, 369, 1, 0, 0, 0, 22, 375, 1, 0, 0, 376 0, 24, 409, 1, 0, 0, 0, 26, 418, 1, 0, 0, 0, 28, 459, 1, 0, 0, 0, 30, 470, 377 1, 0, 0, 0, 32, 488, 1, 0, 0, 0, 34, 540, 1, 0, 0, 0, 36, 546, 1, 0, 0, 378 0, 38, 587, 1, 0, 0, 0, 40, 629, 1, 0, 0, 0, 42, 633, 1, 0, 0, 0, 44, 697, 379 1, 0, 0, 0, 46, 729, 1, 0, 0, 0, 48, 758, 1, 0, 0, 0, 50, 779, 1, 0, 0, 380 0, 52, 793, 1, 0, 0, 0, 54, 804, 1, 0, 0, 0, 56, 824, 1, 0, 0, 0, 58, 837, 381 1, 0, 0, 0, 60, 855, 1, 0, 0, 0, 62, 861, 1, 0, 0, 0, 64, 962, 1, 0, 0, 382 0, 66, 1086, 1, 0, 0, 0, 68, 1096, 1, 0, 0, 0, 70, 1099, 1, 0, 0, 0, 72, 383 1173, 1, 0, 0, 0, 74, 1182, 1, 0, 0, 0, 76, 1229, 1, 0, 0, 0, 78, 1247, 384 1, 0, 0, 0, 80, 1249, 1, 0, 0, 0, 82, 1263, 1, 0, 0, 0, 84, 1280, 1, 0, 385 0, 0, 86, 1381, 1, 0, 0, 0, 88, 1383, 1, 0, 0, 0, 90, 1386, 1, 0, 0, 0, 386 92, 1396, 1, 0, 0, 0, 94, 1482, 1, 0, 0, 0, 96, 1496, 1, 0, 0, 0, 98, 1511, 387 1, 0, 0, 0, 100, 1527, 1, 0, 0, 0, 102, 1535, 1, 0, 0, 0, 104, 1538, 1, 388 0, 0, 0, 106, 1569, 1, 0, 0, 0, 108, 1579, 1, 0, 0, 0, 110, 1584, 1, 0, 389 0, 0, 112, 1596, 1, 0, 0, 0, 114, 1640, 1, 0, 0, 0, 116, 1654, 1, 0, 0, 390 0, 118, 1662, 1, 0, 0, 0, 120, 1668, 1, 0, 0, 0, 122, 1699, 1, 0, 0, 0, 391 124, 1735, 1, 0, 0, 0, 126, 1745, 1, 0, 0, 0, 128, 1754, 1, 0, 0, 0, 130, 392 1769, 1, 0, 0, 0, 132, 1789, 1, 0, 0, 0, 134, 1811, 1, 0, 0, 0, 136, 1823, 393 1, 0, 0, 0, 138, 1833, 1, 0, 0, 0, 140, 1839, 1, 0, 0, 0, 142, 1851, 1, 394 0, 0, 0, 144, 1863, 1, 0, 0, 0, 146, 1875, 1, 0, 0, 0, 148, 1884, 1, 0, 395 0, 0, 150, 1971, 1, 0, 0, 0, 152, 1973, 1, 0, 0, 0, 154, 1976, 1, 0, 0, 396 0, 156, 1979, 1, 0, 0, 0, 158, 1986, 1, 0, 0, 0, 160, 1993, 1, 0, 0, 0, 397 162, 1997, 1, 0, 0, 0, 164, 2011, 1, 0, 0, 0, 166, 2013, 1, 0, 0, 0, 168, 398 2015, 1, 0, 0, 0, 170, 2017, 1, 0, 0, 0, 172, 2021, 1, 0, 0, 0, 174, 2023, 399 1, 0, 0, 0, 176, 2025, 1, 0, 0, 0, 178, 2027, 1, 0, 0, 0, 180, 2029, 1, 400 0, 0, 0, 182, 2031, 1, 0, 0, 0, 184, 2033, 1, 0, 0, 0, 186, 2035, 1, 0, 401 0, 0, 188, 2037, 1, 0, 0, 0, 190, 2039, 1, 0, 0, 0, 192, 2041, 1, 0, 0, 402 0, 194, 2043, 1, 0, 0, 0, 196, 2045, 1, 0, 0, 0, 198, 2047, 1, 0, 0, 0, 403 200, 2049, 1, 0, 0, 0, 202, 2051, 1, 0, 0, 0, 204, 2053, 1, 0, 0, 0, 206, 404 2055, 1, 0, 0, 0, 208, 2057, 1, 0, 0, 0, 210, 2059, 1, 0, 0, 0, 212, 2061, 405 1, 0, 0, 0, 214, 2063, 1, 0, 0, 0, 216, 2065, 1, 0, 0, 0, 218, 2067, 1, 406 0, 0, 0, 220, 2069, 1, 0, 0, 0, 222, 2071, 1, 0, 0, 0, 224, 2080, 1, 0, 407 0, 0, 226, 228, 3, 2, 1, 0, 227, 226, 1, 0, 0, 0, 228, 231, 1, 0, 0, 0, 408 229, 227, 1, 0, 0, 0, 229, 230, 1, 0, 0, 0, 230, 232, 1, 0, 0, 0, 231, 409 229, 1, 0, 0, 0, 232, 233, 5, 0, 0, 1, 233, 1, 1, 0, 0, 0, 234, 236, 5, 410 1, 0, 0, 235, 234, 1, 0, 0, 0, 236, 239, 1, 0, 0, 0, 237, 235, 1, 0, 0, 411 0, 237, 238, 1, 0, 0, 0, 238, 240, 1, 0, 0, 0, 239, 237, 1, 0, 0, 0, 240, 412 249, 3, 4, 2, 0, 241, 243, 5, 1, 0, 0, 242, 241, 1, 0, 0, 0, 243, 244, 413 1, 0, 0, 0, 244, 242, 1, 0, 0, 0, 244, 245, 1, 0, 0, 0, 245, 246, 1, 0, 414 0, 0, 246, 248, 3, 4, 2, 0, 247, 242, 1, 0, 0, 0, 248, 251, 1, 0, 0, 0, 415 249, 247, 1, 0, 0, 0, 249, 250, 1, 0, 0, 0, 250, 255, 1, 0, 0, 0, 251, 416 249, 1, 0, 0, 0, 252, 254, 5, 1, 0, 0, 253, 252, 1, 0, 0, 0, 254, 257, 417 1, 0, 0, 0, 255, 253, 1, 0, 0, 0, 255, 256, 1, 0, 0, 0, 256, 3, 1, 0, 0, 418 0, 257, 255, 1, 0, 0, 0, 258, 261, 5, 71, 0, 0, 259, 260, 5, 114, 0, 0, 419 260, 262, 5, 111, 0, 0, 261, 259, 1, 0, 0, 0, 261, 262, 1, 0, 0, 0, 262, 420 264, 1, 0, 0, 0, 263, 258, 1, 0, 0, 0, 263, 264, 1, 0, 0, 0, 264, 289, 421 1, 0, 0, 0, 265, 290, 3, 6, 3, 0, 266, 290, 3, 8, 4, 0, 267, 290, 3, 10, 422 5, 0, 268, 290, 3, 12, 6, 0, 269, 290, 3, 14, 7, 0, 270, 290, 3, 22, 11, 423 0, 271, 290, 3, 26, 13, 0, 272, 290, 3, 42, 21, 0, 273, 290, 3, 44, 22, 424 0, 274, 290, 3, 46, 23, 0, 275, 290, 3, 56, 28, 0, 276, 290, 3, 58, 29, 425 0, 277, 290, 3, 60, 30, 0, 278, 290, 3, 62, 31, 0, 279, 290, 3, 70, 35, 426 0, 280, 290, 3, 76, 38, 0, 281, 290, 3, 80, 40, 0, 282, 290, 3, 20, 10, 427 0, 283, 290, 3, 16, 8, 0, 284, 290, 3, 18, 9, 0, 285, 290, 3, 82, 41, 0, 428 286, 290, 3, 104, 52, 0, 287, 290, 3, 112, 56, 0, 288, 290, 3, 116, 58, 429 0, 289, 265, 1, 0, 0, 0, 289, 266, 1, 0, 0, 0, 289, 267, 1, 0, 0, 0, 289, 430 268, 1, 0, 0, 0, 289, 269, 1, 0, 0, 0, 289, 270, 1, 0, 0, 0, 289, 271, 431 1, 0, 0, 0, 289, 272, 1, 0, 0, 0, 289, 273, 1, 0, 0, 0, 289, 274, 1, 0, 432 0, 0, 289, 275, 1, 0, 0, 0, 289, 276, 1, 0, 0, 0, 289, 277, 1, 0, 0, 0, 433 289, 278, 1, 0, 0, 0, 289, 279, 1, 0, 0, 0, 289, 280, 1, 0, 0, 0, 289, 434 281, 1, 0, 0, 0, 289, 282, 1, 0, 0, 0, 289, 283, 1, 0, 0, 0, 289, 284, 435 1, 0, 0, 0, 289, 285, 1, 0, 0, 0, 289, 286, 1, 0, 0, 0, 289, 287, 1, 0, 436 0, 0, 289, 288, 1, 0, 0, 0, 290, 5, 1, 0, 0, 0, 291, 292, 5, 30, 0, 0, 437 292, 296, 5, 132, 0, 0, 293, 294, 3, 182, 91, 0, 294, 295, 5, 2, 0, 0, 438 295, 297, 1, 0, 0, 0, 296, 293, 1, 0, 0, 0, 296, 297, 1, 0, 0, 0, 297, 439 298, 1, 0, 0, 0, 298, 321, 3, 184, 92, 0, 299, 309, 5, 121, 0, 0, 300, 440 301, 5, 136, 0, 0, 301, 310, 3, 184, 92, 0, 302, 304, 5, 46, 0, 0, 303, 441 302, 1, 0, 0, 0, 303, 304, 1, 0, 0, 0, 304, 305, 1, 0, 0, 0, 305, 306, 442 3, 188, 94, 0, 306, 307, 5, 136, 0, 0, 307, 308, 3, 188, 94, 0, 308, 310, 443 1, 0, 0, 0, 309, 300, 1, 0, 0, 0, 309, 303, 1, 0, 0, 0, 310, 322, 1, 0, 444 0, 0, 311, 313, 5, 27, 0, 0, 312, 314, 5, 46, 0, 0, 313, 312, 1, 0, 0, 445 0, 313, 314, 1, 0, 0, 0, 314, 315, 1, 0, 0, 0, 315, 322, 3, 28, 14, 0, 446 316, 318, 5, 63, 0, 0, 317, 319, 5, 46, 0, 0, 318, 317, 1, 0, 0, 0, 318, 447 319, 1, 0, 0, 0, 319, 320, 1, 0, 0, 0, 320, 322, 3, 188, 94, 0, 321, 299, 448 1, 0, 0, 0, 321, 311, 1, 0, 0, 0, 321, 316, 1, 0, 0, 0, 322, 7, 1, 0, 0, 449 0, 323, 331, 5, 31, 0, 0, 324, 332, 3, 182, 91, 0, 325, 326, 3, 182, 91, 450 0, 326, 327, 5, 2, 0, 0, 327, 329, 1, 0, 0, 0, 328, 325, 1, 0, 0, 0, 328, 451 329, 1, 0, 0, 0, 329, 330, 1, 0, 0, 0, 330, 332, 3, 186, 93, 0, 331, 324, 452 1, 0, 0, 0, 331, 328, 1, 0, 0, 0, 331, 332, 1, 0, 0, 0, 332, 9, 1, 0, 0, 453 0, 333, 335, 5, 35, 0, 0, 334, 336, 5, 55, 0, 0, 335, 334, 1, 0, 0, 0, 454 335, 336, 1, 0, 0, 0, 336, 337, 1, 0, 0, 0, 337, 338, 3, 64, 32, 0, 338, 455 339, 5, 33, 0, 0, 339, 340, 3, 182, 91, 0, 340, 11, 1, 0, 0, 0, 341, 343, 456 5, 38, 0, 0, 342, 344, 7, 0, 0, 0, 343, 342, 1, 0, 0, 0, 343, 344, 1, 0, 457 0, 0, 344, 349, 1, 0, 0, 0, 345, 347, 5, 137, 0, 0, 346, 348, 3, 208, 104, 458 0, 347, 346, 1, 0, 0, 0, 347, 348, 1, 0, 0, 0, 348, 350, 1, 0, 0, 0, 349, 459 345, 1, 0, 0, 0, 349, 350, 1, 0, 0, 0, 350, 13, 1, 0, 0, 0, 351, 353, 7, 460 1, 0, 0, 352, 354, 5, 137, 0, 0, 353, 352, 1, 0, 0, 0, 353, 354, 1, 0, 461 0, 0, 354, 15, 1, 0, 0, 0, 355, 357, 5, 126, 0, 0, 356, 358, 5, 137, 0, 462 0, 357, 356, 1, 0, 0, 0, 357, 358, 1, 0, 0, 0, 358, 364, 1, 0, 0, 0, 359, 463 361, 5, 136, 0, 0, 360, 362, 5, 129, 0, 0, 361, 360, 1, 0, 0, 0, 361, 362, 464 1, 0, 0, 0, 362, 363, 1, 0, 0, 0, 363, 365, 3, 204, 102, 0, 364, 359, 1, 465 0, 0, 0, 364, 365, 1, 0, 0, 0, 365, 17, 1, 0, 0, 0, 366, 367, 5, 129, 0, 466 0, 367, 368, 3, 204, 102, 0, 368, 19, 1, 0, 0, 0, 369, 371, 5, 120, 0, 467 0, 370, 372, 5, 129, 0, 0, 371, 370, 1, 0, 0, 0, 371, 372, 1, 0, 0, 0, 468 372, 373, 1, 0, 0, 0, 373, 374, 3, 204, 102, 0, 374, 21, 1, 0, 0, 0, 375, 469 377, 5, 50, 0, 0, 376, 378, 5, 140, 0, 0, 377, 376, 1, 0, 0, 0, 377, 378, 470 1, 0, 0, 0, 378, 379, 1, 0, 0, 0, 379, 383, 5, 84, 0, 0, 380, 381, 5, 80, 471 0, 0, 381, 382, 5, 102, 0, 0, 382, 384, 5, 70, 0, 0, 383, 380, 1, 0, 0, 472 0, 383, 384, 1, 0, 0, 0, 384, 388, 1, 0, 0, 0, 385, 386, 3, 182, 91, 0, 473 386, 387, 5, 2, 0, 0, 387, 389, 1, 0, 0, 0, 388, 385, 1, 0, 0, 0, 388, 474 389, 1, 0, 0, 0, 389, 390, 1, 0, 0, 0, 390, 391, 3, 194, 97, 0, 391, 392, 475 5, 107, 0, 0, 392, 393, 3, 184, 92, 0, 393, 394, 5, 3, 0, 0, 394, 399, 476 3, 24, 12, 0, 395, 396, 5, 5, 0, 0, 396, 398, 3, 24, 12, 0, 397, 395, 1, 477 0, 0, 0, 398, 401, 1, 0, 0, 0, 399, 397, 1, 0, 0, 0, 399, 400, 1, 0, 0, 478 0, 400, 402, 1, 0, 0, 0, 401, 399, 1, 0, 0, 0, 402, 405, 5, 4, 0, 0, 403, 479 404, 5, 148, 0, 0, 404, 406, 3, 64, 32, 0, 405, 403, 1, 0, 0, 0, 405, 406, 480 1, 0, 0, 0, 406, 23, 1, 0, 0, 0, 407, 410, 3, 188, 94, 0, 408, 410, 3, 481 64, 32, 0, 409, 407, 1, 0, 0, 0, 409, 408, 1, 0, 0, 0, 410, 413, 1, 0, 482 0, 0, 411, 412, 5, 45, 0, 0, 412, 414, 3, 190, 95, 0, 413, 411, 1, 0, 0, 483 0, 413, 414, 1, 0, 0, 0, 414, 416, 1, 0, 0, 0, 415, 417, 3, 142, 71, 0, 484 416, 415, 1, 0, 0, 0, 416, 417, 1, 0, 0, 0, 417, 25, 1, 0, 0, 0, 418, 420, 485 5, 50, 0, 0, 419, 421, 7, 2, 0, 0, 420, 419, 1, 0, 0, 0, 420, 421, 1, 0, 486 0, 0, 421, 422, 1, 0, 0, 0, 422, 426, 5, 132, 0, 0, 423, 424, 5, 80, 0, 487 0, 424, 425, 5, 102, 0, 0, 425, 427, 5, 70, 0, 0, 426, 423, 1, 0, 0, 0, 488 426, 427, 1, 0, 0, 0, 427, 431, 1, 0, 0, 0, 428, 429, 3, 182, 91, 0, 429, 489 430, 5, 2, 0, 0, 430, 432, 1, 0, 0, 0, 431, 428, 1, 0, 0, 0, 431, 432, 490 1, 0, 0, 0, 432, 433, 1, 0, 0, 0, 433, 457, 3, 184, 92, 0, 434, 435, 5, 491 3, 0, 0, 435, 440, 3, 28, 14, 0, 436, 437, 5, 5, 0, 0, 437, 439, 3, 28, 492 14, 0, 438, 436, 1, 0, 0, 0, 439, 442, 1, 0, 0, 0, 440, 441, 1, 0, 0, 0, 493 440, 438, 1, 0, 0, 0, 441, 447, 1, 0, 0, 0, 442, 440, 1, 0, 0, 0, 443, 494 444, 5, 5, 0, 0, 444, 446, 3, 36, 18, 0, 445, 443, 1, 0, 0, 0, 446, 449, 495 1, 0, 0, 0, 447, 445, 1, 0, 0, 0, 447, 448, 1, 0, 0, 0, 448, 450, 1, 0, 496 0, 0, 449, 447, 1, 0, 0, 0, 450, 453, 5, 4, 0, 0, 451, 452, 5, 150, 0, 497 0, 452, 454, 5, 185, 0, 0, 453, 451, 1, 0, 0, 0, 453, 454, 1, 0, 0, 0, 498 454, 458, 1, 0, 0, 0, 455, 456, 5, 33, 0, 0, 456, 458, 3, 82, 41, 0, 457, 499 434, 1, 0, 0, 0, 457, 455, 1, 0, 0, 0, 458, 27, 1, 0, 0, 0, 459, 461, 3, 500 188, 94, 0, 460, 462, 3, 30, 15, 0, 461, 460, 1, 0, 0, 0, 461, 462, 1, 501 0, 0, 0, 462, 466, 1, 0, 0, 0, 463, 465, 3, 32, 16, 0, 464, 463, 1, 0, 502 0, 0, 465, 468, 1, 0, 0, 0, 466, 464, 1, 0, 0, 0, 466, 467, 1, 0, 0, 0, 503 467, 29, 1, 0, 0, 0, 468, 466, 1, 0, 0, 0, 469, 471, 3, 178, 89, 0, 470, 504 469, 1, 0, 0, 0, 471, 472, 1, 0, 0, 0, 472, 473, 1, 0, 0, 0, 472, 470, 505 1, 0, 0, 0, 473, 484, 1, 0, 0, 0, 474, 475, 5, 3, 0, 0, 475, 476, 3, 34, 506 17, 0, 476, 477, 5, 4, 0, 0, 477, 485, 1, 0, 0, 0, 478, 479, 5, 3, 0, 0, 507 479, 480, 3, 34, 17, 0, 480, 481, 5, 5, 0, 0, 481, 482, 3, 34, 17, 0, 482, 508 483, 5, 4, 0, 0, 483, 485, 1, 0, 0, 0, 484, 474, 1, 0, 0, 0, 484, 478, 509 1, 0, 0, 0, 484, 485, 1, 0, 0, 0, 485, 31, 1, 0, 0, 0, 486, 487, 5, 49, 510 0, 0, 487, 489, 3, 178, 89, 0, 488, 486, 1, 0, 0, 0, 488, 489, 1, 0, 0, 511 0, 489, 537, 1, 0, 0, 0, 490, 491, 5, 113, 0, 0, 491, 493, 5, 95, 0, 0, 512 492, 494, 3, 142, 71, 0, 493, 492, 1, 0, 0, 0, 493, 494, 1, 0, 0, 0, 494, 513 496, 1, 0, 0, 0, 495, 497, 3, 40, 20, 0, 496, 495, 1, 0, 0, 0, 496, 497, 514 1, 0, 0, 0, 497, 499, 1, 0, 0, 0, 498, 500, 5, 36, 0, 0, 499, 498, 1, 0, 515 0, 0, 499, 500, 1, 0, 0, 0, 500, 538, 1, 0, 0, 0, 501, 502, 5, 102, 0, 516 0, 502, 505, 5, 104, 0, 0, 503, 505, 5, 140, 0, 0, 504, 501, 1, 0, 0, 0, 517 504, 503, 1, 0, 0, 0, 505, 507, 1, 0, 0, 0, 506, 508, 3, 40, 20, 0, 507, 518 506, 1, 0, 0, 0, 507, 508, 1, 0, 0, 0, 508, 538, 1, 0, 0, 0, 509, 510, 519 5, 44, 0, 0, 510, 511, 5, 3, 0, 0, 511, 512, 3, 64, 32, 0, 512, 513, 5, 520 4, 0, 0, 513, 538, 1, 0, 0, 0, 514, 521, 5, 56, 0, 0, 515, 522, 3, 34, 521 17, 0, 516, 522, 3, 68, 34, 0, 517, 518, 5, 3, 0, 0, 518, 519, 3, 64, 32, 522 0, 519, 520, 5, 4, 0, 0, 520, 522, 1, 0, 0, 0, 521, 515, 1, 0, 0, 0, 521, 523 516, 1, 0, 0, 0, 521, 517, 1, 0, 0, 0, 522, 538, 1, 0, 0, 0, 523, 524, 524 5, 45, 0, 0, 524, 538, 3, 190, 95, 0, 525, 538, 3, 38, 19, 0, 526, 527, 525 5, 169, 0, 0, 527, 529, 5, 170, 0, 0, 528, 526, 1, 0, 0, 0, 528, 529, 1, 526 0, 0, 0, 529, 530, 1, 0, 0, 0, 530, 531, 5, 33, 0, 0, 531, 532, 5, 3, 0, 527 0, 532, 533, 3, 64, 32, 0, 533, 535, 5, 4, 0, 0, 534, 536, 7, 3, 0, 0, 528 535, 534, 1, 0, 0, 0, 535, 536, 1, 0, 0, 0, 536, 538, 1, 0, 0, 0, 537, 529 490, 1, 0, 0, 0, 537, 504, 1, 0, 0, 0, 537, 509, 1, 0, 0, 0, 537, 514, 530 1, 0, 0, 0, 537, 523, 1, 0, 0, 0, 537, 525, 1, 0, 0, 0, 537, 528, 1, 0, 531 0, 0, 538, 33, 1, 0, 0, 0, 539, 541, 7, 4, 0, 0, 540, 539, 1, 0, 0, 0, 532 540, 541, 1, 0, 0, 0, 541, 542, 1, 0, 0, 0, 542, 543, 5, 186, 0, 0, 543, 533 35, 1, 0, 0, 0, 544, 545, 5, 49, 0, 0, 545, 547, 3, 178, 89, 0, 546, 544, 534 1, 0, 0, 0, 546, 547, 1, 0, 0, 0, 547, 585, 1, 0, 0, 0, 548, 549, 5, 113, 535 0, 0, 549, 552, 5, 95, 0, 0, 550, 552, 5, 140, 0, 0, 551, 548, 1, 0, 0, 536 0, 551, 550, 1, 0, 0, 0, 552, 553, 1, 0, 0, 0, 553, 554, 5, 3, 0, 0, 554, 537 559, 3, 24, 12, 0, 555, 556, 5, 5, 0, 0, 556, 558, 3, 24, 12, 0, 557, 555, 538 1, 0, 0, 0, 558, 561, 1, 0, 0, 0, 559, 557, 1, 0, 0, 0, 559, 560, 1, 0, 539 0, 0, 560, 562, 1, 0, 0, 0, 561, 559, 1, 0, 0, 0, 562, 564, 5, 4, 0, 0, 540 563, 565, 3, 40, 20, 0, 564, 563, 1, 0, 0, 0, 564, 565, 1, 0, 0, 0, 565, 541 586, 1, 0, 0, 0, 566, 567, 5, 44, 0, 0, 567, 568, 5, 3, 0, 0, 568, 569, 542 3, 64, 32, 0, 569, 570, 5, 4, 0, 0, 570, 586, 1, 0, 0, 0, 571, 572, 5, 543 74, 0, 0, 572, 573, 5, 95, 0, 0, 573, 574, 5, 3, 0, 0, 574, 579, 3, 188, 544 94, 0, 575, 576, 5, 5, 0, 0, 576, 578, 3, 188, 94, 0, 577, 575, 1, 0, 0, 545 0, 578, 581, 1, 0, 0, 0, 579, 577, 1, 0, 0, 0, 579, 580, 1, 0, 0, 0, 580, 546 582, 1, 0, 0, 0, 581, 579, 1, 0, 0, 0, 582, 583, 5, 4, 0, 0, 583, 584, 547 3, 38, 19, 0, 584, 586, 1, 0, 0, 0, 585, 551, 1, 0, 0, 0, 585, 566, 1, 548 0, 0, 0, 585, 571, 1, 0, 0, 0, 586, 37, 1, 0, 0, 0, 587, 588, 5, 117, 0, 549 0, 588, 600, 3, 192, 96, 0, 589, 590, 5, 3, 0, 0, 590, 595, 3, 188, 94, 550 0, 591, 592, 5, 5, 0, 0, 592, 594, 3, 188, 94, 0, 593, 591, 1, 0, 0, 0, 551 594, 597, 1, 0, 0, 0, 595, 593, 1, 0, 0, 0, 595, 596, 1, 0, 0, 0, 596, 552 598, 1, 0, 0, 0, 597, 595, 1, 0, 0, 0, 598, 599, 5, 4, 0, 0, 599, 601, 553 1, 0, 0, 0, 600, 589, 1, 0, 0, 0, 600, 601, 1, 0, 0, 0, 601, 616, 1, 0, 554 0, 0, 602, 603, 5, 107, 0, 0, 603, 610, 7, 5, 0, 0, 604, 605, 5, 131, 0, 555 0, 605, 611, 7, 6, 0, 0, 606, 611, 5, 41, 0, 0, 607, 611, 5, 123, 0, 0, 556 608, 609, 5, 101, 0, 0, 609, 611, 5, 26, 0, 0, 610, 604, 1, 0, 0, 0, 610, 557 606, 1, 0, 0, 0, 610, 607, 1, 0, 0, 0, 610, 608, 1, 0, 0, 0, 611, 615, 558 1, 0, 0, 0, 612, 613, 5, 99, 0, 0, 613, 615, 3, 178, 89, 0, 614, 602, 1, 559 0, 0, 0, 614, 612, 1, 0, 0, 0, 615, 618, 1, 0, 0, 0, 616, 614, 1, 0, 0, 560 0, 616, 617, 1, 0, 0, 0, 617, 627, 1, 0, 0, 0, 618, 616, 1, 0, 0, 0, 619, 561 621, 5, 102, 0, 0, 620, 619, 1, 0, 0, 0, 620, 621, 1, 0, 0, 0, 621, 622, 562 1, 0, 0, 0, 622, 625, 5, 57, 0, 0, 623, 624, 5, 86, 0, 0, 624, 626, 7, 563 7, 0, 0, 625, 623, 1, 0, 0, 0, 625, 626, 1, 0, 0, 0, 626, 628, 1, 0, 0, 564 0, 627, 620, 1, 0, 0, 0, 627, 628, 1, 0, 0, 0, 628, 39, 1, 0, 0, 0, 629, 565 630, 5, 107, 0, 0, 630, 631, 5, 48, 0, 0, 631, 632, 7, 8, 0, 0, 632, 41, 566 1, 0, 0, 0, 633, 635, 5, 50, 0, 0, 634, 636, 7, 2, 0, 0, 635, 634, 1, 0, 567 0, 0, 635, 636, 1, 0, 0, 0, 636, 637, 1, 0, 0, 0, 637, 641, 5, 138, 0, 568 0, 638, 639, 5, 80, 0, 0, 639, 640, 5, 102, 0, 0, 640, 642, 5, 70, 0, 0, 569 641, 638, 1, 0, 0, 0, 641, 642, 1, 0, 0, 0, 642, 646, 1, 0, 0, 0, 643, 570 644, 3, 182, 91, 0, 644, 645, 5, 2, 0, 0, 645, 647, 1, 0, 0, 0, 646, 643, 571 1, 0, 0, 0, 646, 647, 1, 0, 0, 0, 647, 648, 1, 0, 0, 0, 648, 653, 3, 196, 572 98, 0, 649, 654, 5, 37, 0, 0, 650, 654, 5, 28, 0, 0, 651, 652, 5, 89, 0, 573 0, 652, 654, 5, 105, 0, 0, 653, 649, 1, 0, 0, 0, 653, 650, 1, 0, 0, 0, 574 653, 651, 1, 0, 0, 0, 653, 654, 1, 0, 0, 0, 654, 669, 1, 0, 0, 0, 655, 575 670, 5, 59, 0, 0, 656, 670, 5, 88, 0, 0, 657, 667, 5, 141, 0, 0, 658, 659, 576 5, 105, 0, 0, 659, 664, 3, 188, 94, 0, 660, 661, 5, 5, 0, 0, 661, 663, 577 3, 188, 94, 0, 662, 660, 1, 0, 0, 0, 663, 666, 1, 0, 0, 0, 664, 662, 1, 578 0, 0, 0, 664, 665, 1, 0, 0, 0, 665, 668, 1, 0, 0, 0, 666, 664, 1, 0, 0, 579 0, 667, 658, 1, 0, 0, 0, 667, 668, 1, 0, 0, 0, 668, 670, 1, 0, 0, 0, 669, 580 655, 1, 0, 0, 0, 669, 656, 1, 0, 0, 0, 669, 657, 1, 0, 0, 0, 670, 671, 581 1, 0, 0, 0, 671, 672, 5, 107, 0, 0, 672, 676, 3, 184, 92, 0, 673, 674, 582 5, 73, 0, 0, 674, 675, 5, 64, 0, 0, 675, 677, 5, 127, 0, 0, 676, 673, 1, 583 0, 0, 0, 676, 677, 1, 0, 0, 0, 677, 680, 1, 0, 0, 0, 678, 679, 5, 147, 584 0, 0, 679, 681, 3, 64, 32, 0, 680, 678, 1, 0, 0, 0, 680, 681, 1, 0, 0, 585 0, 681, 682, 1, 0, 0, 0, 682, 691, 5, 38, 0, 0, 683, 688, 3, 104, 52, 0, 586 684, 688, 3, 70, 35, 0, 685, 688, 3, 56, 28, 0, 686, 688, 3, 82, 41, 0, 587 687, 683, 1, 0, 0, 0, 687, 684, 1, 0, 0, 0, 687, 685, 1, 0, 0, 0, 687, 588 686, 1, 0, 0, 0, 688, 689, 1, 0, 0, 0, 689, 690, 5, 1, 0, 0, 690, 692, 589 1, 0, 0, 0, 691, 687, 1, 0, 0, 0, 692, 693, 1, 0, 0, 0, 693, 691, 1, 0, 590 0, 0, 693, 694, 1, 0, 0, 0, 694, 695, 1, 0, 0, 0, 695, 696, 5, 66, 0, 0, 591 696, 43, 1, 0, 0, 0, 697, 699, 5, 50, 0, 0, 698, 700, 7, 2, 0, 0, 699, 592 698, 1, 0, 0, 0, 699, 700, 1, 0, 0, 0, 700, 701, 1, 0, 0, 0, 701, 705, 593 5, 145, 0, 0, 702, 703, 5, 80, 0, 0, 703, 704, 5, 102, 0, 0, 704, 706, 594 5, 70, 0, 0, 705, 702, 1, 0, 0, 0, 705, 706, 1, 0, 0, 0, 706, 710, 1, 0, 595 0, 0, 707, 708, 3, 182, 91, 0, 708, 709, 5, 2, 0, 0, 709, 711, 1, 0, 0, 596 0, 710, 707, 1, 0, 0, 0, 710, 711, 1, 0, 0, 0, 711, 712, 1, 0, 0, 0, 712, 597 724, 3, 198, 99, 0, 713, 714, 5, 3, 0, 0, 714, 719, 3, 188, 94, 0, 715, 598 716, 5, 5, 0, 0, 716, 718, 3, 188, 94, 0, 717, 715, 1, 0, 0, 0, 718, 721, 599 1, 0, 0, 0, 719, 717, 1, 0, 0, 0, 719, 720, 1, 0, 0, 0, 720, 722, 1, 0, 600 0, 0, 721, 719, 1, 0, 0, 0, 722, 723, 5, 4, 0, 0, 723, 725, 1, 0, 0, 0, 601 724, 713, 1, 0, 0, 0, 724, 725, 1, 0, 0, 0, 725, 726, 1, 0, 0, 0, 726, 602 727, 5, 33, 0, 0, 727, 728, 3, 82, 41, 0, 728, 45, 1, 0, 0, 0, 729, 730, 603 5, 50, 0, 0, 730, 731, 5, 146, 0, 0, 731, 735, 5, 132, 0, 0, 732, 733, 604 5, 80, 0, 0, 733, 734, 5, 102, 0, 0, 734, 736, 5, 70, 0, 0, 735, 732, 1, 605 0, 0, 0, 735, 736, 1, 0, 0, 0, 736, 740, 1, 0, 0, 0, 737, 738, 3, 182, 606 91, 0, 738, 739, 5, 2, 0, 0, 739, 741, 1, 0, 0, 0, 740, 737, 1, 0, 0, 0, 607 740, 741, 1, 0, 0, 0, 741, 742, 1, 0, 0, 0, 742, 743, 3, 184, 92, 0, 743, 608 744, 5, 142, 0, 0, 744, 756, 3, 200, 100, 0, 745, 746, 5, 3, 0, 0, 746, 609 751, 3, 172, 86, 0, 747, 748, 5, 5, 0, 0, 748, 750, 3, 172, 86, 0, 749, 610 747, 1, 0, 0, 0, 750, 753, 1, 0, 0, 0, 751, 749, 1, 0, 0, 0, 751, 752, 611 1, 0, 0, 0, 752, 754, 1, 0, 0, 0, 753, 751, 1, 0, 0, 0, 754, 755, 5, 4, 612 0, 0, 755, 757, 1, 0, 0, 0, 756, 745, 1, 0, 0, 0, 756, 757, 1, 0, 0, 0, 613 757, 47, 1, 0, 0, 0, 758, 760, 5, 149, 0, 0, 759, 761, 5, 116, 0, 0, 760, 614 759, 1, 0, 0, 0, 760, 761, 1, 0, 0, 0, 761, 762, 1, 0, 0, 0, 762, 763, 615 3, 50, 25, 0, 763, 764, 5, 33, 0, 0, 764, 765, 5, 3, 0, 0, 765, 766, 3, 616 82, 41, 0, 766, 776, 5, 4, 0, 0, 767, 768, 5, 5, 0, 0, 768, 769, 3, 50, 617 25, 0, 769, 770, 5, 33, 0, 0, 770, 771, 5, 3, 0, 0, 771, 772, 3, 82, 41, 618 0, 772, 773, 5, 4, 0, 0, 773, 775, 1, 0, 0, 0, 774, 767, 1, 0, 0, 0, 775, 619 778, 1, 0, 0, 0, 776, 774, 1, 0, 0, 0, 776, 777, 1, 0, 0, 0, 777, 49, 1, 620 0, 0, 0, 778, 776, 1, 0, 0, 0, 779, 791, 3, 184, 92, 0, 780, 781, 5, 3, 621 0, 0, 781, 786, 3, 188, 94, 0, 782, 783, 5, 5, 0, 0, 783, 785, 3, 188, 622 94, 0, 784, 782, 1, 0, 0, 0, 785, 788, 1, 0, 0, 0, 786, 784, 1, 0, 0, 0, 623 786, 787, 1, 0, 0, 0, 787, 789, 1, 0, 0, 0, 788, 786, 1, 0, 0, 0, 789, 624 790, 5, 4, 0, 0, 790, 792, 1, 0, 0, 0, 791, 780, 1, 0, 0, 0, 791, 792, 625 1, 0, 0, 0, 792, 51, 1, 0, 0, 0, 793, 794, 3, 50, 25, 0, 794, 795, 5, 33, 626 0, 0, 795, 796, 5, 3, 0, 0, 796, 797, 3, 164, 82, 0, 797, 799, 5, 139, 627 0, 0, 798, 800, 5, 29, 0, 0, 799, 798, 1, 0, 0, 0, 799, 800, 1, 0, 0, 0, 628 800, 801, 1, 0, 0, 0, 801, 802, 3, 166, 83, 0, 802, 803, 5, 4, 0, 0, 803, 629 53, 1, 0, 0, 0, 804, 816, 3, 184, 92, 0, 805, 806, 5, 3, 0, 0, 806, 811, 630 3, 188, 94, 0, 807, 808, 5, 5, 0, 0, 808, 810, 3, 188, 94, 0, 809, 807, 631 1, 0, 0, 0, 810, 813, 1, 0, 0, 0, 811, 809, 1, 0, 0, 0, 811, 812, 1, 0, 632 0, 0, 812, 814, 1, 0, 0, 0, 813, 811, 1, 0, 0, 0, 814, 815, 5, 4, 0, 0, 633 815, 817, 1, 0, 0, 0, 816, 805, 1, 0, 0, 0, 816, 817, 1, 0, 0, 0, 817, 634 818, 1, 0, 0, 0, 818, 819, 5, 33, 0, 0, 819, 820, 5, 3, 0, 0, 820, 821, 635 3, 82, 41, 0, 821, 822, 5, 4, 0, 0, 822, 55, 1, 0, 0, 0, 823, 825, 3, 48, 636 24, 0, 824, 823, 1, 0, 0, 0, 824, 825, 1, 0, 0, 0, 825, 826, 1, 0, 0, 0, 637 826, 827, 5, 59, 0, 0, 827, 828, 5, 75, 0, 0, 828, 831, 3, 114, 57, 0, 638 829, 830, 5, 148, 0, 0, 830, 832, 3, 64, 32, 0, 831, 829, 1, 0, 0, 0, 831, 639 832, 1, 0, 0, 0, 832, 834, 1, 0, 0, 0, 833, 835, 3, 72, 36, 0, 834, 833, 640 1, 0, 0, 0, 834, 835, 1, 0, 0, 0, 835, 57, 1, 0, 0, 0, 836, 838, 3, 48, 641 24, 0, 837, 836, 1, 0, 0, 0, 837, 838, 1, 0, 0, 0, 838, 839, 1, 0, 0, 0, 642 839, 840, 5, 59, 0, 0, 840, 841, 5, 75, 0, 0, 841, 844, 3, 114, 57, 0, 643 842, 843, 5, 148, 0, 0, 843, 845, 3, 64, 32, 0, 844, 842, 1, 0, 0, 0, 844, 644 845, 1, 0, 0, 0, 845, 847, 1, 0, 0, 0, 846, 848, 3, 72, 36, 0, 847, 846, 645 1, 0, 0, 0, 847, 848, 1, 0, 0, 0, 848, 853, 1, 0, 0, 0, 849, 851, 3, 136, 646 68, 0, 850, 849, 1, 0, 0, 0, 850, 851, 1, 0, 0, 0, 851, 852, 1, 0, 0, 0, 647 852, 854, 3, 138, 69, 0, 853, 850, 1, 0, 0, 0, 853, 854, 1, 0, 0, 0, 854, 648 59, 1, 0, 0, 0, 855, 857, 5, 61, 0, 0, 856, 858, 5, 55, 0, 0, 857, 856, 649 1, 0, 0, 0, 857, 858, 1, 0, 0, 0, 858, 859, 1, 0, 0, 0, 859, 860, 3, 182, 650 91, 0, 860, 61, 1, 0, 0, 0, 861, 862, 5, 63, 0, 0, 862, 865, 7, 9, 0, 0, 651 863, 864, 5, 80, 0, 0, 864, 866, 5, 70, 0, 0, 865, 863, 1, 0, 0, 0, 865, 652 866, 1, 0, 0, 0, 866, 870, 1, 0, 0, 0, 867, 868, 3, 182, 91, 0, 868, 869, 653 5, 2, 0, 0, 869, 871, 1, 0, 0, 0, 870, 867, 1, 0, 0, 0, 870, 871, 1, 0, 654 0, 0, 871, 872, 1, 0, 0, 0, 872, 873, 3, 224, 112, 0, 873, 63, 1, 0, 0, 655 0, 874, 875, 6, 32, -1, 0, 875, 963, 3, 68, 34, 0, 876, 963, 5, 187, 0, 656 0, 877, 878, 3, 182, 91, 0, 878, 879, 5, 2, 0, 0, 879, 881, 1, 0, 0, 0, 657 880, 877, 1, 0, 0, 0, 880, 881, 1, 0, 0, 0, 881, 882, 1, 0, 0, 0, 882, 658 883, 3, 184, 92, 0, 883, 884, 5, 2, 0, 0, 884, 886, 1, 0, 0, 0, 885, 880, 659 1, 0, 0, 0, 885, 886, 1, 0, 0, 0, 886, 887, 1, 0, 0, 0, 887, 963, 3, 188, 660 94, 0, 888, 889, 3, 168, 84, 0, 889, 890, 3, 64, 32, 21, 890, 963, 1, 0, 661 0, 0, 891, 892, 3, 180, 90, 0, 892, 905, 5, 3, 0, 0, 893, 895, 5, 62, 0, 662 0, 894, 893, 1, 0, 0, 0, 894, 895, 1, 0, 0, 0, 895, 896, 1, 0, 0, 0, 896, 663 901, 3, 64, 32, 0, 897, 898, 5, 5, 0, 0, 898, 900, 3, 64, 32, 0, 899, 897, 664 1, 0, 0, 0, 900, 903, 1, 0, 0, 0, 901, 899, 1, 0, 0, 0, 901, 902, 1, 0, 665 0, 0, 902, 906, 1, 0, 0, 0, 903, 901, 1, 0, 0, 0, 904, 906, 5, 7, 0, 0, 666 905, 894, 1, 0, 0, 0, 905, 904, 1, 0, 0, 0, 905, 906, 1, 0, 0, 0, 906, 667 907, 1, 0, 0, 0, 907, 909, 5, 4, 0, 0, 908, 910, 3, 118, 59, 0, 909, 908, 668 1, 0, 0, 0, 909, 910, 1, 0, 0, 0, 910, 912, 1, 0, 0, 0, 911, 913, 3, 122, 669 61, 0, 912, 911, 1, 0, 0, 0, 912, 913, 1, 0, 0, 0, 913, 963, 1, 0, 0, 0, 670 914, 915, 5, 3, 0, 0, 915, 920, 3, 64, 32, 0, 916, 917, 5, 5, 0, 0, 917, 671 919, 3, 64, 32, 0, 918, 916, 1, 0, 0, 0, 919, 922, 1, 0, 0, 0, 920, 918, 672 1, 0, 0, 0, 920, 921, 1, 0, 0, 0, 921, 923, 1, 0, 0, 0, 922, 920, 1, 0, 673 0, 0, 923, 924, 5, 4, 0, 0, 924, 963, 1, 0, 0, 0, 925, 926, 5, 43, 0, 0, 674 926, 927, 5, 3, 0, 0, 927, 928, 3, 64, 32, 0, 928, 929, 5, 33, 0, 0, 929, 675 930, 3, 30, 15, 0, 930, 931, 5, 4, 0, 0, 931, 963, 1, 0, 0, 0, 932, 934, 676 5, 102, 0, 0, 933, 932, 1, 0, 0, 0, 933, 934, 1, 0, 0, 0, 934, 935, 1, 677 0, 0, 0, 935, 937, 5, 70, 0, 0, 936, 933, 1, 0, 0, 0, 936, 937, 1, 0, 0, 678 0, 937, 938, 1, 0, 0, 0, 938, 939, 5, 3, 0, 0, 939, 940, 3, 82, 41, 0, 679 940, 941, 5, 4, 0, 0, 941, 963, 1, 0, 0, 0, 942, 944, 5, 42, 0, 0, 943, 680 945, 3, 64, 32, 0, 944, 943, 1, 0, 0, 0, 944, 945, 1, 0, 0, 0, 945, 951, 681 1, 0, 0, 0, 946, 947, 5, 147, 0, 0, 947, 948, 3, 64, 32, 0, 948, 949, 5, 682 135, 0, 0, 949, 950, 3, 64, 32, 0, 950, 952, 1, 0, 0, 0, 951, 946, 1, 0, 683 0, 0, 952, 953, 1, 0, 0, 0, 953, 951, 1, 0, 0, 0, 953, 954, 1, 0, 0, 0, 684 954, 957, 1, 0, 0, 0, 955, 956, 5, 65, 0, 0, 956, 958, 3, 64, 32, 0, 957, 685 955, 1, 0, 0, 0, 957, 958, 1, 0, 0, 0, 958, 959, 1, 0, 0, 0, 959, 960, 686 5, 66, 0, 0, 960, 963, 1, 0, 0, 0, 961, 963, 3, 66, 33, 0, 962, 874, 1, 687 0, 0, 0, 962, 876, 1, 0, 0, 0, 962, 885, 1, 0, 0, 0, 962, 888, 1, 0, 0, 688 0, 962, 891, 1, 0, 0, 0, 962, 914, 1, 0, 0, 0, 962, 925, 1, 0, 0, 0, 962, 689 936, 1, 0, 0, 0, 962, 942, 1, 0, 0, 0, 962, 961, 1, 0, 0, 0, 963, 1083, 690 1, 0, 0, 0, 964, 965, 10, 20, 0, 0, 965, 966, 5, 11, 0, 0, 966, 1082, 3, 691 64, 32, 21, 967, 968, 10, 19, 0, 0, 968, 969, 7, 10, 0, 0, 969, 1082, 3, 692 64, 32, 20, 970, 971, 10, 18, 0, 0, 971, 972, 7, 4, 0, 0, 972, 1082, 3, 693 64, 32, 19, 973, 974, 10, 17, 0, 0, 974, 975, 7, 11, 0, 0, 975, 1082, 3, 694 64, 32, 18, 976, 977, 10, 16, 0, 0, 977, 978, 7, 12, 0, 0, 978, 1082, 3, 695 64, 32, 17, 979, 992, 10, 15, 0, 0, 980, 993, 5, 6, 0, 0, 981, 993, 5, 696 22, 0, 0, 982, 993, 5, 23, 0, 0, 983, 993, 5, 24, 0, 0, 984, 993, 5, 92, 697 0, 0, 985, 986, 5, 92, 0, 0, 986, 993, 5, 102, 0, 0, 987, 993, 5, 83, 0, 698 0, 988, 993, 5, 97, 0, 0, 989, 993, 5, 77, 0, 0, 990, 993, 5, 99, 0, 0, 699 991, 993, 5, 118, 0, 0, 992, 980, 1, 0, 0, 0, 992, 981, 1, 0, 0, 0, 992, 700 982, 1, 0, 0, 0, 992, 983, 1, 0, 0, 0, 992, 984, 1, 0, 0, 0, 992, 985, 701 1, 0, 0, 0, 992, 987, 1, 0, 0, 0, 992, 988, 1, 0, 0, 0, 992, 989, 1, 0, 702 0, 0, 992, 990, 1, 0, 0, 0, 992, 991, 1, 0, 0, 0, 993, 994, 1, 0, 0, 0, 703 994, 1082, 3, 64, 32, 16, 995, 996, 10, 14, 0, 0, 996, 997, 5, 32, 0, 0, 704 997, 1082, 3, 64, 32, 15, 998, 999, 10, 13, 0, 0, 999, 1000, 5, 108, 0, 705 0, 1000, 1082, 3, 64, 32, 14, 1001, 1002, 10, 6, 0, 0, 1002, 1004, 5, 92, 706 0, 0, 1003, 1005, 5, 102, 0, 0, 1004, 1003, 1, 0, 0, 0, 1004, 1005, 1, 707 0, 0, 0, 1005, 1006, 1, 0, 0, 0, 1006, 1082, 3, 64, 32, 7, 1007, 1009, 708 10, 5, 0, 0, 1008, 1010, 5, 102, 0, 0, 1009, 1008, 1, 0, 0, 0, 1009, 1010, 709 1, 0, 0, 0, 1010, 1011, 1, 0, 0, 0, 1011, 1012, 5, 39, 0, 0, 1012, 1013, 710 3, 64, 32, 0, 1013, 1014, 5, 32, 0, 0, 1014, 1015, 3, 64, 32, 6, 1015, 711 1082, 1, 0, 0, 0, 1016, 1017, 10, 9, 0, 0, 1017, 1018, 5, 45, 0, 0, 1018, 712 1082, 3, 190, 95, 0, 1019, 1021, 10, 8, 0, 0, 1020, 1022, 5, 102, 0, 0, 713 1021, 1020, 1, 0, 0, 0, 1021, 1022, 1, 0, 0, 0, 1022, 1023, 1, 0, 0, 0, 714 1023, 1024, 7, 13, 0, 0, 1024, 1027, 3, 64, 32, 0, 1025, 1026, 5, 67, 0, 715 0, 1026, 1028, 3, 64, 32, 0, 1027, 1025, 1, 0, 0, 0, 1027, 1028, 1, 0, 716 0, 0, 1028, 1082, 1, 0, 0, 0, 1029, 1034, 10, 7, 0, 0, 1030, 1035, 5, 93, 717 0, 0, 1031, 1035, 5, 103, 0, 0, 1032, 1033, 5, 102, 0, 0, 1033, 1035, 5, 718 104, 0, 0, 1034, 1030, 1, 0, 0, 0, 1034, 1031, 1, 0, 0, 0, 1034, 1032, 719 1, 0, 0, 0, 1035, 1082, 1, 0, 0, 0, 1036, 1038, 10, 4, 0, 0, 1037, 1039, 720 5, 102, 0, 0, 1038, 1037, 1, 0, 0, 0, 1038, 1039, 1, 0, 0, 0, 1039, 1040, 721 1, 0, 0, 0, 1040, 1079, 5, 83, 0, 0, 1041, 1051, 5, 3, 0, 0, 1042, 1052, 722 3, 82, 41, 0, 1043, 1048, 3, 64, 32, 0, 1044, 1045, 5, 5, 0, 0, 1045, 1047, 723 3, 64, 32, 0, 1046, 1044, 1, 0, 0, 0, 1047, 1050, 1, 0, 0, 0, 1048, 1046, 724 1, 0, 0, 0, 1048, 1049, 1, 0, 0, 0, 1049, 1052, 1, 0, 0, 0, 1050, 1048, 725 1, 0, 0, 0, 1051, 1042, 1, 0, 0, 0, 1051, 1043, 1, 0, 0, 0, 1051, 1052, 726 1, 0, 0, 0, 1052, 1053, 1, 0, 0, 0, 1053, 1080, 5, 4, 0, 0, 1054, 1055, 727 3, 182, 91, 0, 1055, 1056, 5, 2, 0, 0, 1056, 1058, 1, 0, 0, 0, 1057, 1054, 728 1, 0, 0, 0, 1057, 1058, 1, 0, 0, 0, 1058, 1059, 1, 0, 0, 0, 1059, 1080, 729 3, 184, 92, 0, 1060, 1061, 3, 182, 91, 0, 1061, 1062, 5, 2, 0, 0, 1062, 730 1064, 1, 0, 0, 0, 1063, 1060, 1, 0, 0, 0, 1063, 1064, 1, 0, 0, 0, 1064, 731 1065, 1, 0, 0, 0, 1065, 1066, 3, 222, 111, 0, 1066, 1075, 5, 3, 0, 0, 1067, 732 1072, 3, 64, 32, 0, 1068, 1069, 5, 5, 0, 0, 1069, 1071, 3, 64, 32, 0, 1070, 733 1068, 1, 0, 0, 0, 1071, 1074, 1, 0, 0, 0, 1072, 1070, 1, 0, 0, 0, 1072, 734 1073, 1, 0, 0, 0, 1073, 1076, 1, 0, 0, 0, 1074, 1072, 1, 0, 0, 0, 1075, 735 1067, 1, 0, 0, 0, 1075, 1076, 1, 0, 0, 0, 1076, 1077, 1, 0, 0, 0, 1077, 736 1078, 5, 4, 0, 0, 1078, 1080, 1, 0, 0, 0, 1079, 1041, 1, 0, 0, 0, 1079, 737 1057, 1, 0, 0, 0, 1079, 1063, 1, 0, 0, 0, 1080, 1082, 1, 0, 0, 0, 1081, 738 964, 1, 0, 0, 0, 1081, 967, 1, 0, 0, 0, 1081, 970, 1, 0, 0, 0, 1081, 973, 739 1, 0, 0, 0, 1081, 976, 1, 0, 0, 0, 1081, 979, 1, 0, 0, 0, 1081, 995, 1, 740 0, 0, 0, 1081, 998, 1, 0, 0, 0, 1081, 1001, 1, 0, 0, 0, 1081, 1007, 1, 741 0, 0, 0, 1081, 1016, 1, 0, 0, 0, 1081, 1019, 1, 0, 0, 0, 1081, 1029, 1, 742 0, 0, 0, 1081, 1036, 1, 0, 0, 0, 1082, 1085, 1, 0, 0, 0, 1083, 1081, 1, 743 0, 0, 0, 1083, 1084, 1, 0, 0, 0, 1084, 65, 1, 0, 0, 0, 1085, 1083, 1, 0, 744 0, 0, 1086, 1087, 5, 115, 0, 0, 1087, 1092, 5, 3, 0, 0, 1088, 1093, 5, 745 81, 0, 0, 1089, 1090, 7, 14, 0, 0, 1090, 1091, 5, 5, 0, 0, 1091, 1093, 746 3, 170, 85, 0, 1092, 1088, 1, 0, 0, 0, 1092, 1089, 1, 0, 0, 0, 1093, 1094, 747 1, 0, 0, 0, 1094, 1095, 5, 4, 0, 0, 1095, 67, 1, 0, 0, 0, 1096, 1097, 7, 748 15, 0, 0, 1097, 69, 1, 0, 0, 0, 1098, 1100, 3, 48, 24, 0, 1099, 1098, 1, 749 0, 0, 0, 1099, 1100, 1, 0, 0, 0, 1100, 1106, 1, 0, 0, 0, 1101, 1107, 5, 750 88, 0, 0, 1102, 1107, 5, 122, 0, 0, 1103, 1104, 5, 88, 0, 0, 1104, 1105, 751 5, 108, 0, 0, 1105, 1107, 7, 8, 0, 0, 1106, 1101, 1, 0, 0, 0, 1106, 1102, 752 1, 0, 0, 0, 1106, 1103, 1, 0, 0, 0, 1107, 1108, 1, 0, 0, 0, 1108, 1112, 753 5, 91, 0, 0, 1109, 1110, 3, 182, 91, 0, 1110, 1111, 5, 2, 0, 0, 1111, 1113, 754 1, 0, 0, 0, 1112, 1109, 1, 0, 0, 0, 1112, 1113, 1, 0, 0, 0, 1113, 1114, 755 1, 0, 0, 0, 1114, 1117, 3, 184, 92, 0, 1115, 1116, 5, 33, 0, 0, 1116, 1118, 756 3, 206, 103, 0, 1117, 1115, 1, 0, 0, 0, 1117, 1118, 1, 0, 0, 0, 1118, 1130, 757 1, 0, 0, 0, 1119, 1120, 5, 3, 0, 0, 1120, 1125, 3, 188, 94, 0, 1121, 1122, 758 5, 5, 0, 0, 1122, 1124, 3, 188, 94, 0, 1123, 1121, 1, 0, 0, 0, 1124, 1127, 759 1, 0, 0, 0, 1125, 1123, 1, 0, 0, 0, 1125, 1126, 1, 0, 0, 0, 1126, 1128, 760 1, 0, 0, 0, 1127, 1125, 1, 0, 0, 0, 1128, 1129, 5, 4, 0, 0, 1129, 1131, 761 1, 0, 0, 0, 1130, 1119, 1, 0, 0, 0, 1130, 1131, 1, 0, 0, 0, 1131, 1168, 762 1, 0, 0, 0, 1132, 1133, 5, 144, 0, 0, 1133, 1134, 5, 3, 0, 0, 1134, 1139, 763 3, 64, 32, 0, 1135, 1136, 5, 5, 0, 0, 1136, 1138, 3, 64, 32, 0, 1137, 1135, 764 1, 0, 0, 0, 1138, 1141, 1, 0, 0, 0, 1139, 1137, 1, 0, 0, 0, 1139, 1140, 765 1, 0, 0, 0, 1140, 1142, 1, 0, 0, 0, 1141, 1139, 1, 0, 0, 0, 1142, 1157, 766 5, 4, 0, 0, 1143, 1144, 5, 5, 0, 0, 1144, 1145, 5, 3, 0, 0, 1145, 1150, 767 3, 64, 32, 0, 1146, 1147, 5, 5, 0, 0, 1147, 1149, 3, 64, 32, 0, 1148, 1146, 768 1, 0, 0, 0, 1149, 1152, 1, 0, 0, 0, 1150, 1148, 1, 0, 0, 0, 1150, 1151, 769 1, 0, 0, 0, 1151, 1153, 1, 0, 0, 0, 1152, 1150, 1, 0, 0, 0, 1153, 1154, 770 5, 4, 0, 0, 1154, 1156, 1, 0, 0, 0, 1155, 1143, 1, 0, 0, 0, 1156, 1159, 771 1, 0, 0, 0, 1157, 1155, 1, 0, 0, 0, 1157, 1158, 1, 0, 0, 0, 1158, 1162, 772 1, 0, 0, 0, 1159, 1157, 1, 0, 0, 0, 1160, 1162, 3, 82, 41, 0, 1161, 1132, 773 1, 0, 0, 0, 1161, 1160, 1, 0, 0, 0, 1162, 1164, 1, 0, 0, 0, 1163, 1165, 774 3, 74, 37, 0, 1164, 1163, 1, 0, 0, 0, 1164, 1165, 1, 0, 0, 0, 1165, 1169, 775 1, 0, 0, 0, 1166, 1167, 5, 56, 0, 0, 1167, 1169, 5, 144, 0, 0, 1168, 1161, 776 1, 0, 0, 0, 1168, 1166, 1, 0, 0, 0, 1169, 1171, 1, 0, 0, 0, 1170, 1172, 777 3, 72, 36, 0, 1171, 1170, 1, 0, 0, 0, 1171, 1172, 1, 0, 0, 0, 1172, 71, 778 1, 0, 0, 0, 1173, 1174, 5, 124, 0, 0, 1174, 1179, 3, 96, 48, 0, 1175, 1176, 779 5, 5, 0, 0, 1176, 1178, 3, 96, 48, 0, 1177, 1175, 1, 0, 0, 0, 1178, 1181, 780 1, 0, 0, 0, 1179, 1177, 1, 0, 0, 0, 1179, 1180, 1, 0, 0, 0, 1180, 73, 1, 781 0, 0, 0, 1181, 1179, 1, 0, 0, 0, 1182, 1183, 5, 107, 0, 0, 1183, 1198, 782 5, 48, 0, 0, 1184, 1185, 5, 3, 0, 0, 1185, 1190, 3, 24, 12, 0, 1186, 1187, 783 5, 5, 0, 0, 1187, 1189, 3, 24, 12, 0, 1188, 1186, 1, 0, 0, 0, 1189, 1192, 784 1, 0, 0, 0, 1190, 1188, 1, 0, 0, 0, 1190, 1191, 1, 0, 0, 0, 1191, 1193, 785 1, 0, 0, 0, 1192, 1190, 1, 0, 0, 0, 1193, 1196, 5, 4, 0, 0, 1194, 1195, 786 5, 148, 0, 0, 1195, 1197, 3, 64, 32, 0, 1196, 1194, 1, 0, 0, 0, 1196, 1197, 787 1, 0, 0, 0, 1197, 1199, 1, 0, 0, 0, 1198, 1184, 1, 0, 0, 0, 1198, 1199, 788 1, 0, 0, 0, 1199, 1200, 1, 0, 0, 0, 1200, 1227, 5, 183, 0, 0, 1201, 1228, 789 5, 184, 0, 0, 1202, 1203, 5, 141, 0, 0, 1203, 1206, 5, 131, 0, 0, 1204, 790 1207, 3, 188, 94, 0, 1205, 1207, 3, 110, 55, 0, 1206, 1204, 1, 0, 0, 0, 791 1206, 1205, 1, 0, 0, 0, 1207, 1208, 1, 0, 0, 0, 1208, 1209, 5, 6, 0, 0, 792 1209, 1220, 3, 64, 32, 0, 1210, 1213, 5, 5, 0, 0, 1211, 1214, 3, 188, 94, 793 0, 1212, 1214, 3, 110, 55, 0, 1213, 1211, 1, 0, 0, 0, 1213, 1212, 1, 0, 794 0, 0, 1214, 1215, 1, 0, 0, 0, 1215, 1216, 5, 6, 0, 0, 1216, 1217, 3, 64, 795 32, 0, 1217, 1219, 1, 0, 0, 0, 1218, 1210, 1, 0, 0, 0, 1219, 1222, 1, 0, 796 0, 0, 1220, 1218, 1, 0, 0, 0, 1220, 1221, 1, 0, 0, 0, 1221, 1225, 1, 0, 797 0, 0, 1222, 1220, 1, 0, 0, 0, 1223, 1224, 5, 148, 0, 0, 1224, 1226, 3, 798 64, 32, 0, 1225, 1223, 1, 0, 0, 0, 1225, 1226, 1, 0, 0, 0, 1226, 1228, 799 1, 0, 0, 0, 1227, 1201, 1, 0, 0, 0, 1227, 1202, 1, 0, 0, 0, 1228, 75, 1, 800 0, 0, 0, 1229, 1233, 5, 112, 0, 0, 1230, 1231, 3, 182, 91, 0, 1231, 1232, 801 5, 2, 0, 0, 1232, 1234, 1, 0, 0, 0, 1233, 1230, 1, 0, 0, 0, 1233, 1234, 802 1, 0, 0, 0, 1234, 1235, 1, 0, 0, 0, 1235, 1242, 3, 202, 101, 0, 1236, 1237, 803 5, 6, 0, 0, 1237, 1243, 3, 78, 39, 0, 1238, 1239, 5, 3, 0, 0, 1239, 1240, 804 3, 78, 39, 0, 1240, 1241, 5, 4, 0, 0, 1241, 1243, 1, 0, 0, 0, 1242, 1236, 805 1, 0, 0, 0, 1242, 1238, 1, 0, 0, 0, 1242, 1243, 1, 0, 0, 0, 1243, 77, 1, 806 0, 0, 0, 1244, 1248, 3, 34, 17, 0, 1245, 1248, 3, 178, 89, 0, 1246, 1248, 807 5, 188, 0, 0, 1247, 1244, 1, 0, 0, 0, 1247, 1245, 1, 0, 0, 0, 1247, 1246, 808 1, 0, 0, 0, 1248, 79, 1, 0, 0, 0, 1249, 1260, 5, 119, 0, 0, 1250, 1261, 809 3, 190, 95, 0, 1251, 1252, 3, 182, 91, 0, 1252, 1253, 5, 2, 0, 0, 1253, 810 1255, 1, 0, 0, 0, 1254, 1251, 1, 0, 0, 0, 1254, 1255, 1, 0, 0, 0, 1255, 811 1258, 1, 0, 0, 0, 1256, 1259, 3, 184, 92, 0, 1257, 1259, 3, 194, 97, 0, 812 1258, 1256, 1, 0, 0, 0, 1258, 1257, 1, 0, 0, 0, 1259, 1261, 1, 0, 0, 0, 813 1260, 1250, 1, 0, 0, 0, 1260, 1254, 1, 0, 0, 0, 1260, 1261, 1, 0, 0, 0, 814 1261, 81, 1, 0, 0, 0, 1262, 1264, 3, 134, 67, 0, 1263, 1262, 1, 0, 0, 0, 815 1263, 1264, 1, 0, 0, 0, 1264, 1265, 1, 0, 0, 0, 1265, 1271, 3, 86, 43, 816 0, 1266, 1267, 3, 102, 51, 0, 1267, 1268, 3, 86, 43, 0, 1268, 1270, 1, 817 0, 0, 0, 1269, 1266, 1, 0, 0, 0, 1270, 1273, 1, 0, 0, 0, 1271, 1269, 1, 818 0, 0, 0, 1271, 1272, 1, 0, 0, 0, 1272, 1275, 1, 0, 0, 0, 1273, 1271, 1, 819 0, 0, 0, 1274, 1276, 3, 136, 68, 0, 1275, 1274, 1, 0, 0, 0, 1275, 1276, 820 1, 0, 0, 0, 1276, 1278, 1, 0, 0, 0, 1277, 1279, 3, 138, 69, 0, 1278, 1277, 821 1, 0, 0, 0, 1278, 1279, 1, 0, 0, 0, 1279, 83, 1, 0, 0, 0, 1280, 1288, 3, 822 94, 47, 0, 1281, 1282, 3, 98, 49, 0, 1282, 1284, 3, 94, 47, 0, 1283, 1285, 823 3, 100, 50, 0, 1284, 1283, 1, 0, 0, 0, 1284, 1285, 1, 0, 0, 0, 1285, 1287, 824 1, 0, 0, 0, 1286, 1281, 1, 0, 0, 0, 1287, 1290, 1, 0, 0, 0, 1288, 1286, 825 1, 0, 0, 0, 1288, 1289, 1, 0, 0, 0, 1289, 85, 1, 0, 0, 0, 1290, 1288, 1, 826 0, 0, 0, 1291, 1293, 5, 130, 0, 0, 1292, 1294, 7, 16, 0, 0, 1293, 1292, 827 1, 0, 0, 0, 1293, 1294, 1, 0, 0, 0, 1294, 1295, 1, 0, 0, 0, 1295, 1300, 828 3, 96, 48, 0, 1296, 1297, 5, 5, 0, 0, 1297, 1299, 3, 96, 48, 0, 1298, 1296, 829 1, 0, 0, 0, 1299, 1302, 1, 0, 0, 0, 1300, 1298, 1, 0, 0, 0, 1300, 1301, 830 1, 0, 0, 0, 1301, 1315, 1, 0, 0, 0, 1302, 1300, 1, 0, 0, 0, 1303, 1313, 831 5, 75, 0, 0, 1304, 1309, 3, 94, 47, 0, 1305, 1306, 5, 5, 0, 0, 1306, 1308, 832 3, 94, 47, 0, 1307, 1305, 1, 0, 0, 0, 1308, 1311, 1, 0, 0, 0, 1309, 1307, 833 1, 0, 0, 0, 1309, 1310, 1, 0, 0, 0, 1310, 1314, 1, 0, 0, 0, 1311, 1309, 834 1, 0, 0, 0, 1312, 1314, 3, 84, 42, 0, 1313, 1304, 1, 0, 0, 0, 1313, 1312, 835 1, 0, 0, 0, 1314, 1316, 1, 0, 0, 0, 1315, 1303, 1, 0, 0, 0, 1315, 1316, 836 1, 0, 0, 0, 1316, 1319, 1, 0, 0, 0, 1317, 1318, 5, 148, 0, 0, 1318, 1320, 837 3, 64, 32, 0, 1319, 1317, 1, 0, 0, 0, 1319, 1320, 1, 0, 0, 0, 1320, 1335, 838 1, 0, 0, 0, 1321, 1322, 5, 78, 0, 0, 1322, 1323, 5, 40, 0, 0, 1323, 1328, 839 3, 64, 32, 0, 1324, 1325, 5, 5, 0, 0, 1325, 1327, 3, 64, 32, 0, 1326, 1324, 840 1, 0, 0, 0, 1327, 1330, 1, 0, 0, 0, 1328, 1326, 1, 0, 0, 0, 1328, 1329, 841 1, 0, 0, 0, 1329, 1333, 1, 0, 0, 0, 1330, 1328, 1, 0, 0, 0, 1331, 1332, 842 5, 79, 0, 0, 1332, 1334, 3, 64, 32, 0, 1333, 1331, 1, 0, 0, 0, 1333, 1334, 843 1, 0, 0, 0, 1334, 1336, 1, 0, 0, 0, 1335, 1321, 1, 0, 0, 0, 1335, 1336, 844 1, 0, 0, 0, 1336, 1351, 1, 0, 0, 0, 1337, 1338, 5, 174, 0, 0, 1338, 1339, 845 3, 210, 105, 0, 1339, 1340, 5, 33, 0, 0, 1340, 1348, 3, 120, 60, 0, 1341, 846 1342, 5, 5, 0, 0, 1342, 1343, 3, 210, 105, 0, 1343, 1344, 5, 33, 0, 0, 847 1344, 1345, 3, 120, 60, 0, 1345, 1347, 1, 0, 0, 0, 1346, 1341, 1, 0, 0, 848 0, 1347, 1350, 1, 0, 0, 0, 1348, 1346, 1, 0, 0, 0, 1348, 1349, 1, 0, 0, 849 0, 1349, 1352, 1, 0, 0, 0, 1350, 1348, 1, 0, 0, 0, 1351, 1337, 1, 0, 0, 850 0, 1351, 1352, 1, 0, 0, 0, 1352, 1382, 1, 0, 0, 0, 1353, 1354, 5, 144, 851 0, 0, 1354, 1355, 5, 3, 0, 0, 1355, 1360, 3, 64, 32, 0, 1356, 1357, 5, 852 5, 0, 0, 1357, 1359, 3, 64, 32, 0, 1358, 1356, 1, 0, 0, 0, 1359, 1362, 853 1, 0, 0, 0, 1360, 1358, 1, 0, 0, 0, 1360, 1361, 1, 0, 0, 0, 1361, 1363, 854 1, 0, 0, 0, 1362, 1360, 1, 0, 0, 0, 1363, 1378, 5, 4, 0, 0, 1364, 1365, 855 5, 5, 0, 0, 1365, 1366, 5, 3, 0, 0, 1366, 1371, 3, 64, 32, 0, 1367, 1368, 856 5, 5, 0, 0, 1368, 1370, 3, 64, 32, 0, 1369, 1367, 1, 0, 0, 0, 1370, 1373, 857 1, 0, 0, 0, 1371, 1369, 1, 0, 0, 0, 1371, 1372, 1, 0, 0, 0, 1372, 1374, 858 1, 0, 0, 0, 1373, 1371, 1, 0, 0, 0, 1374, 1375, 5, 4, 0, 0, 1375, 1377, 859 1, 0, 0, 0, 1376, 1364, 1, 0, 0, 0, 1377, 1380, 1, 0, 0, 0, 1378, 1376, 860 1, 0, 0, 0, 1378, 1379, 1, 0, 0, 0, 1379, 1382, 1, 0, 0, 0, 1380, 1378, 861 1, 0, 0, 0, 1381, 1291, 1, 0, 0, 0, 1381, 1353, 1, 0, 0, 0, 1382, 87, 1, 862 0, 0, 0, 1383, 1384, 3, 82, 41, 0, 1384, 89, 1, 0, 0, 0, 1385, 1387, 3, 863 134, 67, 0, 1386, 1385, 1, 0, 0, 0, 1386, 1387, 1, 0, 0, 0, 1387, 1388, 864 1, 0, 0, 0, 1388, 1390, 3, 86, 43, 0, 1389, 1391, 3, 136, 68, 0, 1390, 865 1389, 1, 0, 0, 0, 1390, 1391, 1, 0, 0, 0, 1391, 1393, 1, 0, 0, 0, 1392, 866 1394, 3, 138, 69, 0, 1393, 1392, 1, 0, 0, 0, 1393, 1394, 1, 0, 0, 0, 1394, 867 91, 1, 0, 0, 0, 1395, 1397, 3, 134, 67, 0, 1396, 1395, 1, 0, 0, 0, 1396, 868 1397, 1, 0, 0, 0, 1397, 1398, 1, 0, 0, 0, 1398, 1408, 3, 86, 43, 0, 1399, 869 1401, 5, 139, 0, 0, 1400, 1402, 5, 29, 0, 0, 1401, 1400, 1, 0, 0, 0, 1401, 870 1402, 1, 0, 0, 0, 1402, 1406, 1, 0, 0, 0, 1403, 1406, 5, 90, 0, 0, 1404, 871 1406, 5, 68, 0, 0, 1405, 1399, 1, 0, 0, 0, 1405, 1403, 1, 0, 0, 0, 1405, 872 1404, 1, 0, 0, 0, 1406, 1407, 1, 0, 0, 0, 1407, 1409, 3, 86, 43, 0, 1408, 873 1405, 1, 0, 0, 0, 1409, 1410, 1, 0, 0, 0, 1410, 1408, 1, 0, 0, 0, 1410, 874 1411, 1, 0, 0, 0, 1411, 1413, 1, 0, 0, 0, 1412, 1414, 3, 136, 68, 0, 1413, 875 1412, 1, 0, 0, 0, 1413, 1414, 1, 0, 0, 0, 1414, 1416, 1, 0, 0, 0, 1415, 876 1417, 3, 138, 69, 0, 1416, 1415, 1, 0, 0, 0, 1416, 1417, 1, 0, 0, 0, 1417, 877 93, 1, 0, 0, 0, 1418, 1419, 3, 182, 91, 0, 1419, 1420, 5, 2, 0, 0, 1420, 878 1422, 1, 0, 0, 0, 1421, 1418, 1, 0, 0, 0, 1421, 1422, 1, 0, 0, 0, 1422, 879 1423, 1, 0, 0, 0, 1423, 1428, 3, 184, 92, 0, 1424, 1426, 5, 33, 0, 0, 1425, 880 1424, 1, 0, 0, 0, 1425, 1426, 1, 0, 0, 0, 1426, 1427, 1, 0, 0, 0, 1427, 881 1429, 3, 206, 103, 0, 1428, 1425, 1, 0, 0, 0, 1428, 1429, 1, 0, 0, 0, 1429, 882 1435, 1, 0, 0, 0, 1430, 1431, 5, 85, 0, 0, 1431, 1432, 5, 40, 0, 0, 1432, 883 1436, 3, 194, 97, 0, 1433, 1434, 5, 102, 0, 0, 1434, 1436, 5, 85, 0, 0, 884 1435, 1430, 1, 0, 0, 0, 1435, 1433, 1, 0, 0, 0, 1435, 1436, 1, 0, 0, 0, 885 1436, 1483, 1, 0, 0, 0, 1437, 1438, 3, 182, 91, 0, 1438, 1439, 5, 2, 0, 886 0, 1439, 1441, 1, 0, 0, 0, 1440, 1437, 1, 0, 0, 0, 1440, 1441, 1, 0, 0, 887 0, 1441, 1442, 1, 0, 0, 0, 1442, 1443, 3, 222, 111, 0, 1443, 1444, 5, 3, 888 0, 0, 1444, 1449, 3, 64, 32, 0, 1445, 1446, 5, 5, 0, 0, 1446, 1448, 3, 889 64, 32, 0, 1447, 1445, 1, 0, 0, 0, 1448, 1451, 1, 0, 0, 0, 1449, 1447, 890 1, 0, 0, 0, 1449, 1450, 1, 0, 0, 0, 1450, 1452, 1, 0, 0, 0, 1451, 1449, 891 1, 0, 0, 0, 1452, 1457, 5, 4, 0, 0, 1453, 1455, 5, 33, 0, 0, 1454, 1453, 892 1, 0, 0, 0, 1454, 1455, 1, 0, 0, 0, 1455, 1456, 1, 0, 0, 0, 1456, 1458, 893 3, 206, 103, 0, 1457, 1454, 1, 0, 0, 0, 1457, 1458, 1, 0, 0, 0, 1458, 1483, 894 1, 0, 0, 0, 1459, 1469, 5, 3, 0, 0, 1460, 1465, 3, 94, 47, 0, 1461, 1462, 895 5, 5, 0, 0, 1462, 1464, 3, 94, 47, 0, 1463, 1461, 1, 0, 0, 0, 1464, 1467, 896 1, 0, 0, 0, 1465, 1463, 1, 0, 0, 0, 1465, 1466, 1, 0, 0, 0, 1466, 1470, 897 1, 0, 0, 0, 1467, 1465, 1, 0, 0, 0, 1468, 1470, 3, 84, 42, 0, 1469, 1460, 898 1, 0, 0, 0, 1469, 1468, 1, 0, 0, 0, 1470, 1471, 1, 0, 0, 0, 1471, 1472, 899 5, 4, 0, 0, 1472, 1483, 1, 0, 0, 0, 1473, 1474, 5, 3, 0, 0, 1474, 1475, 900 3, 82, 41, 0, 1475, 1480, 5, 4, 0, 0, 1476, 1478, 5, 33, 0, 0, 1477, 1476, 901 1, 0, 0, 0, 1477, 1478, 1, 0, 0, 0, 1478, 1479, 1, 0, 0, 0, 1479, 1481, 902 3, 206, 103, 0, 1480, 1477, 1, 0, 0, 0, 1480, 1481, 1, 0, 0, 0, 1481, 1483, 903 1, 0, 0, 0, 1482, 1421, 1, 0, 0, 0, 1482, 1440, 1, 0, 0, 0, 1482, 1459, 904 1, 0, 0, 0, 1482, 1473, 1, 0, 0, 0, 1483, 95, 1, 0, 0, 0, 1484, 1497, 5, 905 7, 0, 0, 1485, 1486, 3, 184, 92, 0, 1486, 1487, 5, 2, 0, 0, 1487, 1488, 906 5, 7, 0, 0, 1488, 1497, 1, 0, 0, 0, 1489, 1494, 3, 64, 32, 0, 1490, 1492, 907 5, 33, 0, 0, 1491, 1490, 1, 0, 0, 0, 1491, 1492, 1, 0, 0, 0, 1492, 1493, 908 1, 0, 0, 0, 1493, 1495, 3, 174, 87, 0, 1494, 1491, 1, 0, 0, 0, 1494, 1495, 909 1, 0, 0, 0, 1495, 1497, 1, 0, 0, 0, 1496, 1484, 1, 0, 0, 0, 1496, 1485, 910 1, 0, 0, 0, 1496, 1489, 1, 0, 0, 0, 1497, 97, 1, 0, 0, 0, 1498, 1512, 5, 911 5, 0, 0, 1499, 1501, 5, 100, 0, 0, 1500, 1499, 1, 0, 0, 0, 1500, 1501, 912 1, 0, 0, 0, 1501, 1508, 1, 0, 0, 0, 1502, 1504, 5, 96, 0, 0, 1503, 1505, 913 5, 110, 0, 0, 1504, 1503, 1, 0, 0, 0, 1504, 1505, 1, 0, 0, 0, 1505, 1509, 914 1, 0, 0, 0, 1506, 1509, 5, 87, 0, 0, 1507, 1509, 5, 51, 0, 0, 1508, 1502, 915 1, 0, 0, 0, 1508, 1506, 1, 0, 0, 0, 1508, 1507, 1, 0, 0, 0, 1508, 1509, 916 1, 0, 0, 0, 1509, 1510, 1, 0, 0, 0, 1510, 1512, 5, 94, 0, 0, 1511, 1498, 917 1, 0, 0, 0, 1511, 1500, 1, 0, 0, 0, 1512, 99, 1, 0, 0, 0, 1513, 1514, 5, 918 107, 0, 0, 1514, 1528, 3, 64, 32, 0, 1515, 1516, 5, 142, 0, 0, 1516, 1517, 919 5, 3, 0, 0, 1517, 1522, 3, 188, 94, 0, 1518, 1519, 5, 5, 0, 0, 1519, 1521, 920 3, 188, 94, 0, 1520, 1518, 1, 0, 0, 0, 1521, 1524, 1, 0, 0, 0, 1522, 1520, 921 1, 0, 0, 0, 1522, 1523, 1, 0, 0, 0, 1523, 1525, 1, 0, 0, 0, 1524, 1522, 922 1, 0, 0, 0, 1525, 1526, 5, 4, 0, 0, 1526, 1528, 1, 0, 0, 0, 1527, 1513, 923 1, 0, 0, 0, 1527, 1515, 1, 0, 0, 0, 1528, 101, 1, 0, 0, 0, 1529, 1531, 924 5, 139, 0, 0, 1530, 1532, 5, 29, 0, 0, 1531, 1530, 1, 0, 0, 0, 1531, 1532, 925 1, 0, 0, 0, 1532, 1536, 1, 0, 0, 0, 1533, 1536, 5, 90, 0, 0, 1534, 1536, 926 5, 68, 0, 0, 1535, 1529, 1, 0, 0, 0, 1535, 1533, 1, 0, 0, 0, 1535, 1534, 927 1, 0, 0, 0, 1536, 103, 1, 0, 0, 0, 1537, 1539, 3, 48, 24, 0, 1538, 1537, 928 1, 0, 0, 0, 1538, 1539, 1, 0, 0, 0, 1539, 1540, 1, 0, 0, 0, 1540, 1543, 929 5, 141, 0, 0, 1541, 1542, 5, 108, 0, 0, 1542, 1544, 7, 8, 0, 0, 1543, 1541, 930 1, 0, 0, 0, 1543, 1544, 1, 0, 0, 0, 1544, 1545, 1, 0, 0, 0, 1545, 1546, 931 3, 114, 57, 0, 1546, 1547, 5, 131, 0, 0, 1547, 1560, 3, 106, 53, 0, 1548, 932 1558, 5, 75, 0, 0, 1549, 1554, 3, 94, 47, 0, 1550, 1551, 5, 5, 0, 0, 1551, 933 1553, 3, 94, 47, 0, 1552, 1550, 1, 0, 0, 0, 1553, 1556, 1, 0, 0, 0, 1554, 934 1552, 1, 0, 0, 0, 1554, 1555, 1, 0, 0, 0, 1555, 1559, 1, 0, 0, 0, 1556, 935 1554, 1, 0, 0, 0, 1557, 1559, 3, 84, 42, 0, 1558, 1549, 1, 0, 0, 0, 1558, 936 1557, 1, 0, 0, 0, 1559, 1561, 1, 0, 0, 0, 1560, 1548, 1, 0, 0, 0, 1560, 937 1561, 1, 0, 0, 0, 1561, 1564, 1, 0, 0, 0, 1562, 1563, 5, 148, 0, 0, 1563, 938 1565, 3, 64, 32, 0, 1564, 1562, 1, 0, 0, 0, 1564, 1565, 1, 0, 0, 0, 1565, 939 1567, 1, 0, 0, 0, 1566, 1568, 3, 72, 36, 0, 1567, 1566, 1, 0, 0, 0, 1567, 940 1568, 1, 0, 0, 0, 1568, 105, 1, 0, 0, 0, 1569, 1574, 3, 108, 54, 0, 1570, 941 1571, 5, 5, 0, 0, 1571, 1573, 3, 108, 54, 0, 1572, 1570, 1, 0, 0, 0, 1573, 942 1576, 1, 0, 0, 0, 1574, 1572, 1, 0, 0, 0, 1574, 1575, 1, 0, 0, 0, 1575, 943 107, 1, 0, 0, 0, 1576, 1574, 1, 0, 0, 0, 1577, 1580, 3, 188, 94, 0, 1578, 944 1580, 3, 110, 55, 0, 1579, 1577, 1, 0, 0, 0, 1579, 1578, 1, 0, 0, 0, 1580, 945 1581, 1, 0, 0, 0, 1581, 1582, 5, 6, 0, 0, 1582, 1583, 3, 64, 32, 0, 1583, 946 109, 1, 0, 0, 0, 1584, 1585, 5, 3, 0, 0, 1585, 1590, 3, 188, 94, 0, 1586, 947 1587, 5, 5, 0, 0, 1587, 1589, 3, 188, 94, 0, 1588, 1586, 1, 0, 0, 0, 1589, 948 1592, 1, 0, 0, 0, 1590, 1588, 1, 0, 0, 0, 1590, 1591, 1, 0, 0, 0, 1591, 949 1593, 1, 0, 0, 0, 1592, 1590, 1, 0, 0, 0, 1593, 1594, 5, 4, 0, 0, 1594, 950 111, 1, 0, 0, 0, 1595, 1597, 3, 48, 24, 0, 1596, 1595, 1, 0, 0, 0, 1596, 951 1597, 1, 0, 0, 0, 1597, 1598, 1, 0, 0, 0, 1598, 1601, 5, 141, 0, 0, 1599, 952 1600, 5, 108, 0, 0, 1600, 1602, 7, 8, 0, 0, 1601, 1599, 1, 0, 0, 0, 1601, 953 1602, 1, 0, 0, 0, 1602, 1603, 1, 0, 0, 0, 1603, 1604, 3, 114, 57, 0, 1604, 954 1607, 5, 131, 0, 0, 1605, 1608, 3, 188, 94, 0, 1606, 1608, 3, 110, 55, 955 0, 1607, 1605, 1, 0, 0, 0, 1607, 1606, 1, 0, 0, 0, 1608, 1609, 1, 0, 0, 956 0, 1609, 1610, 5, 6, 0, 0, 1610, 1621, 3, 64, 32, 0, 1611, 1614, 5, 5, 957 0, 0, 1612, 1615, 3, 188, 94, 0, 1613, 1615, 3, 110, 55, 0, 1614, 1612, 958 1, 0, 0, 0, 1614, 1613, 1, 0, 0, 0, 1615, 1616, 1, 0, 0, 0, 1616, 1617, 959 5, 6, 0, 0, 1617, 1618, 3, 64, 32, 0, 1618, 1620, 1, 0, 0, 0, 1619, 1611, 960 1, 0, 0, 0, 1620, 1623, 1, 0, 0, 0, 1621, 1619, 1, 0, 0, 0, 1621, 1622, 961 1, 0, 0, 0, 1622, 1626, 1, 0, 0, 0, 1623, 1621, 1, 0, 0, 0, 1624, 1625, 962 5, 148, 0, 0, 1625, 1627, 3, 64, 32, 0, 1626, 1624, 1, 0, 0, 0, 1626, 1627, 963 1, 0, 0, 0, 1627, 1629, 1, 0, 0, 0, 1628, 1630, 3, 72, 36, 0, 1629, 1628, 964 1, 0, 0, 0, 1629, 1630, 1, 0, 0, 0, 1630, 1635, 1, 0, 0, 0, 1631, 1633, 965 3, 136, 68, 0, 1632, 1631, 1, 0, 0, 0, 1632, 1633, 1, 0, 0, 0, 1633, 1634, 966 1, 0, 0, 0, 1634, 1636, 3, 138, 69, 0, 1635, 1632, 1, 0, 0, 0, 1635, 1636, 967 1, 0, 0, 0, 1636, 113, 1, 0, 0, 0, 1637, 1638, 3, 182, 91, 0, 1638, 1639, 968 5, 2, 0, 0, 1639, 1641, 1, 0, 0, 0, 1640, 1637, 1, 0, 0, 0, 1640, 1641, 969 1, 0, 0, 0, 1641, 1642, 1, 0, 0, 0, 1642, 1645, 3, 184, 92, 0, 1643, 1644, 970 5, 33, 0, 0, 1644, 1646, 3, 212, 106, 0, 1645, 1643, 1, 0, 0, 0, 1645, 971 1646, 1, 0, 0, 0, 1646, 1652, 1, 0, 0, 0, 1647, 1648, 5, 85, 0, 0, 1648, 972 1649, 5, 40, 0, 0, 1649, 1653, 3, 194, 97, 0, 1650, 1651, 5, 102, 0, 0, 973 1651, 1653, 5, 85, 0, 0, 1652, 1647, 1, 0, 0, 0, 1652, 1650, 1, 0, 0, 0, 974 1652, 1653, 1, 0, 0, 0, 1653, 115, 1, 0, 0, 0, 1654, 1656, 5, 143, 0, 0, 975 1655, 1657, 3, 182, 91, 0, 1656, 1655, 1, 0, 0, 0, 1656, 1657, 1, 0, 0, 976 0, 1657, 1660, 1, 0, 0, 0, 1658, 1659, 5, 91, 0, 0, 1659, 1661, 3, 214, 977 107, 0, 1660, 1658, 1, 0, 0, 0, 1660, 1661, 1, 0, 0, 0, 1661, 117, 1, 0, 978 0, 0, 1662, 1663, 5, 178, 0, 0, 1663, 1664, 5, 3, 0, 0, 1664, 1665, 5, 979 148, 0, 0, 1665, 1666, 3, 64, 32, 0, 1666, 1667, 5, 4, 0, 0, 1667, 119, 980 1, 0, 0, 0, 1668, 1670, 5, 3, 0, 0, 1669, 1671, 3, 216, 108, 0, 1670, 1669, 981 1, 0, 0, 0, 1670, 1671, 1, 0, 0, 0, 1671, 1682, 1, 0, 0, 0, 1672, 1673, 982 5, 153, 0, 0, 1673, 1674, 5, 40, 0, 0, 1674, 1679, 3, 64, 32, 0, 1675, 983 1676, 5, 5, 0, 0, 1676, 1678, 3, 64, 32, 0, 1677, 1675, 1, 0, 0, 0, 1678, 984 1681, 1, 0, 0, 0, 1679, 1677, 1, 0, 0, 0, 1679, 1680, 1, 0, 0, 0, 1680, 985 1683, 1, 0, 0, 0, 1681, 1679, 1, 0, 0, 0, 1682, 1672, 1, 0, 0, 0, 1682, 986 1683, 1, 0, 0, 0, 1683, 1684, 1, 0, 0, 0, 1684, 1685, 5, 109, 0, 0, 1685, 987 1686, 5, 40, 0, 0, 1686, 1691, 3, 140, 70, 0, 1687, 1688, 5, 5, 0, 0, 1688, 988 1690, 3, 140, 70, 0, 1689, 1687, 1, 0, 0, 0, 1690, 1693, 1, 0, 0, 0, 1691, 989 1689, 1, 0, 0, 0, 1691, 1692, 1, 0, 0, 0, 1692, 1695, 1, 0, 0, 0, 1693, 990 1691, 1, 0, 0, 0, 1694, 1696, 3, 124, 62, 0, 1695, 1694, 1, 0, 0, 0, 1695, 991 1696, 1, 0, 0, 0, 1696, 1697, 1, 0, 0, 0, 1697, 1698, 5, 4, 0, 0, 1698, 992 121, 1, 0, 0, 0, 1699, 1733, 5, 152, 0, 0, 1700, 1734, 3, 210, 105, 0, 993 1701, 1703, 5, 3, 0, 0, 1702, 1704, 3, 216, 108, 0, 1703, 1702, 1, 0, 0, 994 0, 1703, 1704, 1, 0, 0, 0, 1704, 1715, 1, 0, 0, 0, 1705, 1706, 5, 153, 995 0, 0, 1706, 1707, 5, 40, 0, 0, 1707, 1712, 3, 64, 32, 0, 1708, 1709, 5, 996 5, 0, 0, 1709, 1711, 3, 64, 32, 0, 1710, 1708, 1, 0, 0, 0, 1711, 1714, 997 1, 0, 0, 0, 1712, 1710, 1, 0, 0, 0, 1712, 1713, 1, 0, 0, 0, 1713, 1716, 998 1, 0, 0, 0, 1714, 1712, 1, 0, 0, 0, 1715, 1705, 1, 0, 0, 0, 1715, 1716, 999 1, 0, 0, 0, 1716, 1727, 1, 0, 0, 0, 1717, 1718, 5, 109, 0, 0, 1718, 1719, 1000 5, 40, 0, 0, 1719, 1724, 3, 140, 70, 0, 1720, 1721, 5, 5, 0, 0, 1721, 1723, 1001 3, 140, 70, 0, 1722, 1720, 1, 0, 0, 0, 1723, 1726, 1, 0, 0, 0, 1724, 1722, 1002 1, 0, 0, 0, 1724, 1725, 1, 0, 0, 0, 1725, 1728, 1, 0, 0, 0, 1726, 1724, 1003 1, 0, 0, 0, 1727, 1717, 1, 0, 0, 0, 1727, 1728, 1, 0, 0, 0, 1728, 1730, 1004 1, 0, 0, 0, 1729, 1731, 3, 124, 62, 0, 1730, 1729, 1, 0, 0, 0, 1730, 1731, 1005 1, 0, 0, 0, 1731, 1732, 1, 0, 0, 0, 1732, 1734, 5, 4, 0, 0, 1733, 1700, 1006 1, 0, 0, 0, 1733, 1701, 1, 0, 0, 0, 1734, 123, 1, 0, 0, 0, 1735, 1743, 1007 3, 126, 63, 0, 1736, 1737, 5, 180, 0, 0, 1737, 1738, 5, 101, 0, 0, 1738, 1008 1744, 5, 182, 0, 0, 1739, 1740, 5, 157, 0, 0, 1740, 1744, 5, 127, 0, 0, 1009 1741, 1744, 5, 78, 0, 0, 1742, 1744, 5, 181, 0, 0, 1743, 1736, 1, 0, 0, 1010 0, 1743, 1739, 1, 0, 0, 0, 1743, 1741, 1, 0, 0, 0, 1743, 1742, 1, 0, 0, 1011 0, 1743, 1744, 1, 0, 0, 0, 1744, 125, 1, 0, 0, 0, 1745, 1752, 7, 17, 0, 1012 0, 1746, 1753, 3, 148, 74, 0, 1747, 1748, 5, 39, 0, 0, 1748, 1749, 3, 144, 1013 72, 0, 1749, 1750, 5, 32, 0, 0, 1750, 1751, 3, 146, 73, 0, 1751, 1753, 1014 1, 0, 0, 0, 1752, 1746, 1, 0, 0, 0, 1752, 1747, 1, 0, 0, 0, 1753, 127, 1015 1, 0, 0, 0, 1754, 1755, 3, 218, 109, 0, 1755, 1765, 5, 3, 0, 0, 1756, 1761, 1016 3, 64, 32, 0, 1757, 1758, 5, 5, 0, 0, 1758, 1760, 3, 64, 32, 0, 1759, 1757, 1017 1, 0, 0, 0, 1760, 1763, 1, 0, 0, 0, 1761, 1759, 1, 0, 0, 0, 1761, 1762, 1018 1, 0, 0, 0, 1762, 1766, 1, 0, 0, 0, 1763, 1761, 1, 0, 0, 0, 1764, 1766, 1019 5, 7, 0, 0, 1765, 1756, 1, 0, 0, 0, 1765, 1764, 1, 0, 0, 0, 1766, 1767, 1020 1, 0, 0, 0, 1767, 1768, 5, 4, 0, 0, 1768, 129, 1, 0, 0, 0, 1769, 1770, 1021 3, 220, 110, 0, 1770, 1783, 5, 3, 0, 0, 1771, 1773, 5, 62, 0, 0, 1772, 1022 1771, 1, 0, 0, 0, 1772, 1773, 1, 0, 0, 0, 1773, 1774, 1, 0, 0, 0, 1774, 1023 1779, 3, 64, 32, 0, 1775, 1776, 5, 5, 0, 0, 1776, 1778, 3, 64, 32, 0, 1777, 1024 1775, 1, 0, 0, 0, 1778, 1781, 1, 0, 0, 0, 1779, 1777, 1, 0, 0, 0, 1779, 1025 1780, 1, 0, 0, 0, 1780, 1784, 1, 0, 0, 0, 1781, 1779, 1, 0, 0, 0, 1782, 1026 1784, 5, 7, 0, 0, 1783, 1772, 1, 0, 0, 0, 1783, 1782, 1, 0, 0, 0, 1783, 1027 1784, 1, 0, 0, 0, 1784, 1785, 1, 0, 0, 0, 1785, 1787, 5, 4, 0, 0, 1786, 1028 1788, 3, 118, 59, 0, 1787, 1786, 1, 0, 0, 0, 1787, 1788, 1, 0, 0, 0, 1788, 1029 131, 1, 0, 0, 0, 1789, 1790, 3, 150, 75, 0, 1790, 1800, 5, 3, 0, 0, 1791, 1030 1796, 3, 64, 32, 0, 1792, 1793, 5, 5, 0, 0, 1793, 1795, 3, 64, 32, 0, 1794, 1031 1792, 1, 0, 0, 0, 1795, 1798, 1, 0, 0, 0, 1796, 1794, 1, 0, 0, 0, 1796, 1032 1797, 1, 0, 0, 0, 1797, 1801, 1, 0, 0, 0, 1798, 1796, 1, 0, 0, 0, 1799, 1033 1801, 5, 7, 0, 0, 1800, 1791, 1, 0, 0, 0, 1800, 1799, 1, 0, 0, 0, 1800, 1034 1801, 1, 0, 0, 0, 1801, 1802, 1, 0, 0, 0, 1802, 1804, 5, 4, 0, 0, 1803, 1035 1805, 3, 118, 59, 0, 1804, 1803, 1, 0, 0, 0, 1804, 1805, 1, 0, 0, 0, 1805, 1036 1806, 1, 0, 0, 0, 1806, 1809, 5, 152, 0, 0, 1807, 1810, 3, 120, 60, 0, 1037 1808, 1810, 3, 210, 105, 0, 1809, 1807, 1, 0, 0, 0, 1809, 1808, 1, 0, 0, 1038 0, 1810, 133, 1, 0, 0, 0, 1811, 1813, 5, 149, 0, 0, 1812, 1814, 5, 116, 1039 0, 0, 1813, 1812, 1, 0, 0, 0, 1813, 1814, 1, 0, 0, 0, 1814, 1815, 1, 0, 1040 0, 0, 1815, 1820, 3, 54, 27, 0, 1816, 1817, 5, 5, 0, 0, 1817, 1819, 3, 1041 54, 27, 0, 1818, 1816, 1, 0, 0, 0, 1819, 1822, 1, 0, 0, 0, 1820, 1818, 1042 1, 0, 0, 0, 1820, 1821, 1, 0, 0, 0, 1821, 135, 1, 0, 0, 0, 1822, 1820, 1043 1, 0, 0, 0, 1823, 1824, 5, 109, 0, 0, 1824, 1825, 5, 40, 0, 0, 1825, 1830, 1044 3, 140, 70, 0, 1826, 1827, 5, 5, 0, 0, 1827, 1829, 3, 140, 70, 0, 1828, 1045 1826, 1, 0, 0, 0, 1829, 1832, 1, 0, 0, 0, 1830, 1828, 1, 0, 0, 0, 1830, 1046 1831, 1, 0, 0, 0, 1831, 137, 1, 0, 0, 0, 1832, 1830, 1, 0, 0, 0, 1833, 1047 1834, 5, 98, 0, 0, 1834, 1837, 3, 64, 32, 0, 1835, 1836, 7, 18, 0, 0, 1836, 1048 1838, 3, 64, 32, 0, 1837, 1835, 1, 0, 0, 0, 1837, 1838, 1, 0, 0, 0, 1838, 1049 139, 1, 0, 0, 0, 1839, 1842, 3, 64, 32, 0, 1840, 1841, 5, 45, 0, 0, 1841, 1050 1843, 3, 190, 95, 0, 1842, 1840, 1, 0, 0, 0, 1842, 1843, 1, 0, 0, 0, 1843, 1051 1845, 1, 0, 0, 0, 1844, 1846, 3, 142, 71, 0, 1845, 1844, 1, 0, 0, 0, 1845, 1052 1846, 1, 0, 0, 0, 1846, 1849, 1, 0, 0, 0, 1847, 1848, 5, 175, 0, 0, 1848, 1053 1850, 7, 19, 0, 0, 1849, 1847, 1, 0, 0, 0, 1849, 1850, 1, 0, 0, 0, 1850, 1054 141, 1, 0, 0, 0, 1851, 1852, 7, 20, 0, 0, 1852, 143, 1, 0, 0, 0, 1853, 1055 1854, 3, 64, 32, 0, 1854, 1855, 5, 155, 0, 0, 1855, 1864, 1, 0, 0, 0, 1856, 1056 1857, 3, 64, 32, 0, 1857, 1858, 5, 158, 0, 0, 1858, 1864, 1, 0, 0, 0, 1859, 1057 1860, 5, 157, 0, 0, 1860, 1864, 5, 127, 0, 0, 1861, 1862, 5, 156, 0, 0, 1058 1862, 1864, 5, 155, 0, 0, 1863, 1853, 1, 0, 0, 0, 1863, 1856, 1, 0, 0, 1059 0, 1863, 1859, 1, 0, 0, 0, 1863, 1861, 1, 0, 0, 0, 1864, 145, 1, 0, 0, 1060 0, 1865, 1866, 3, 64, 32, 0, 1866, 1867, 5, 155, 0, 0, 1867, 1876, 1, 0, 1061 0, 0, 1868, 1869, 3, 64, 32, 0, 1869, 1870, 5, 158, 0, 0, 1870, 1876, 1, 1062 0, 0, 0, 1871, 1872, 5, 157, 0, 0, 1872, 1876, 5, 127, 0, 0, 1873, 1874, 1063 5, 156, 0, 0, 1874, 1876, 5, 158, 0, 0, 1875, 1865, 1, 0, 0, 0, 1875, 1868, 1064 1, 0, 0, 0, 1875, 1871, 1, 0, 0, 0, 1875, 1873, 1, 0, 0, 0, 1876, 147, 1065 1, 0, 0, 0, 1877, 1878, 3, 64, 32, 0, 1878, 1879, 5, 155, 0, 0, 1879, 1885, 1066 1, 0, 0, 0, 1880, 1881, 5, 156, 0, 0, 1881, 1885, 5, 155, 0, 0, 1882, 1883, 1067 5, 157, 0, 0, 1883, 1885, 5, 127, 0, 0, 1884, 1877, 1, 0, 0, 0, 1884, 1880, 1068 1, 0, 0, 0, 1884, 1882, 1, 0, 0, 0, 1885, 149, 1, 0, 0, 0, 1886, 1887, 1069 7, 21, 0, 0, 1887, 1888, 5, 3, 0, 0, 1888, 1889, 3, 64, 32, 0, 1889, 1890, 1070 5, 4, 0, 0, 1890, 1891, 5, 152, 0, 0, 1891, 1893, 5, 3, 0, 0, 1892, 1894, 1071 3, 156, 78, 0, 1893, 1892, 1, 0, 0, 0, 1893, 1894, 1, 0, 0, 0, 1894, 1895, 1072 1, 0, 0, 0, 1895, 1897, 3, 160, 80, 0, 1896, 1898, 3, 126, 63, 0, 1897, 1073 1896, 1, 0, 0, 0, 1897, 1898, 1, 0, 0, 0, 1898, 1899, 1, 0, 0, 0, 1899, 1074 1900, 5, 4, 0, 0, 1900, 1972, 1, 0, 0, 0, 1901, 1902, 7, 22, 0, 0, 1902, 1075 1903, 5, 3, 0, 0, 1903, 1904, 5, 4, 0, 0, 1904, 1905, 5, 152, 0, 0, 1905, 1076 1907, 5, 3, 0, 0, 1906, 1908, 3, 156, 78, 0, 1907, 1906, 1, 0, 0, 0, 1907, 1077 1908, 1, 0, 0, 0, 1908, 1910, 1, 0, 0, 0, 1909, 1911, 3, 158, 79, 0, 1910, 1078 1909, 1, 0, 0, 0, 1910, 1911, 1, 0, 0, 0, 1911, 1912, 1, 0, 0, 0, 1912, 1079 1972, 5, 4, 0, 0, 1913, 1914, 7, 23, 0, 0, 1914, 1915, 5, 3, 0, 0, 1915, 1080 1916, 5, 4, 0, 0, 1916, 1917, 5, 152, 0, 0, 1917, 1919, 5, 3, 0, 0, 1918, 1081 1920, 3, 156, 78, 0, 1919, 1918, 1, 0, 0, 0, 1919, 1920, 1, 0, 0, 0, 1920, 1082 1921, 1, 0, 0, 0, 1921, 1922, 3, 160, 80, 0, 1922, 1923, 5, 4, 0, 0, 1923, 1083 1972, 1, 0, 0, 0, 1924, 1925, 7, 24, 0, 0, 1925, 1926, 5, 3, 0, 0, 1926, 1084 1928, 3, 64, 32, 0, 1927, 1929, 3, 152, 76, 0, 1928, 1927, 1, 0, 0, 0, 1085 1928, 1929, 1, 0, 0, 0, 1929, 1931, 1, 0, 0, 0, 1930, 1932, 3, 154, 77, 1086 0, 1931, 1930, 1, 0, 0, 0, 1931, 1932, 1, 0, 0, 0, 1932, 1933, 1, 0, 0, 1087 0, 1933, 1934, 5, 4, 0, 0, 1934, 1935, 5, 152, 0, 0, 1935, 1937, 5, 3, 1088 0, 0, 1936, 1938, 3, 156, 78, 0, 1937, 1936, 1, 0, 0, 0, 1937, 1938, 1, 1089 0, 0, 0, 1938, 1939, 1, 0, 0, 0, 1939, 1940, 3, 160, 80, 0, 1940, 1941, 1090 5, 4, 0, 0, 1941, 1972, 1, 0, 0, 0, 1942, 1943, 5, 164, 0, 0, 1943, 1944, 1091 5, 3, 0, 0, 1944, 1945, 3, 64, 32, 0, 1945, 1946, 5, 5, 0, 0, 1946, 1947, 1092 3, 34, 17, 0, 1947, 1948, 5, 4, 0, 0, 1948, 1949, 5, 152, 0, 0, 1949, 1951, 1093 5, 3, 0, 0, 1950, 1952, 3, 156, 78, 0, 1951, 1950, 1, 0, 0, 0, 1951, 1952, 1094 1, 0, 0, 0, 1952, 1953, 1, 0, 0, 0, 1953, 1955, 3, 160, 80, 0, 1954, 1956, 1095 3, 126, 63, 0, 1955, 1954, 1, 0, 0, 0, 1955, 1956, 1, 0, 0, 0, 1956, 1957, 1096 1, 0, 0, 0, 1957, 1958, 5, 4, 0, 0, 1958, 1972, 1, 0, 0, 0, 1959, 1960, 1097 5, 165, 0, 0, 1960, 1961, 5, 3, 0, 0, 1961, 1962, 3, 64, 32, 0, 1962, 1963, 1098 5, 4, 0, 0, 1963, 1964, 5, 152, 0, 0, 1964, 1966, 5, 3, 0, 0, 1965, 1967, 1099 3, 156, 78, 0, 1966, 1965, 1, 0, 0, 0, 1966, 1967, 1, 0, 0, 0, 1967, 1968, 1100 1, 0, 0, 0, 1968, 1969, 3, 160, 80, 0, 1969, 1970, 5, 4, 0, 0, 1970, 1972, 1101 1, 0, 0, 0, 1971, 1886, 1, 0, 0, 0, 1971, 1901, 1, 0, 0, 0, 1971, 1913, 1102 1, 0, 0, 0, 1971, 1924, 1, 0, 0, 0, 1971, 1942, 1, 0, 0, 0, 1971, 1959, 1103 1, 0, 0, 0, 1972, 151, 1, 0, 0, 0, 1973, 1974, 5, 5, 0, 0, 1974, 1975, 1104 3, 34, 17, 0, 1975, 153, 1, 0, 0, 0, 1976, 1977, 5, 5, 0, 0, 1977, 1978, 1105 3, 34, 17, 0, 1978, 155, 1, 0, 0, 0, 1979, 1980, 5, 153, 0, 0, 1980, 1982, 1106 5, 40, 0, 0, 1981, 1983, 3, 64, 32, 0, 1982, 1981, 1, 0, 0, 0, 1983, 1984, 1107 1, 0, 0, 0, 1984, 1982, 1, 0, 0, 0, 1984, 1985, 1, 0, 0, 0, 1985, 157, 1108 1, 0, 0, 0, 1986, 1987, 5, 109, 0, 0, 1987, 1989, 5, 40, 0, 0, 1988, 1990, 1109 3, 64, 32, 0, 1989, 1988, 1, 0, 0, 0, 1990, 1991, 1, 0, 0, 0, 1991, 1989, 1110 1, 0, 0, 0, 1991, 1992, 1, 0, 0, 0, 1992, 159, 1, 0, 0, 0, 1993, 1994, 1111 5, 109, 0, 0, 1994, 1995, 5, 40, 0, 0, 1995, 1996, 3, 162, 81, 0, 1996, 1112 161, 1, 0, 0, 0, 1997, 1999, 3, 64, 32, 0, 1998, 2000, 3, 142, 71, 0, 1999, 1113 1998, 1, 0, 0, 0, 1999, 2000, 1, 0, 0, 0, 2000, 2008, 1, 0, 0, 0, 2001, 1114 2002, 5, 5, 0, 0, 2002, 2004, 3, 64, 32, 0, 2003, 2005, 3, 142, 71, 0, 1115 2004, 2003, 1, 0, 0, 0, 2004, 2005, 1, 0, 0, 0, 2005, 2007, 1, 0, 0, 0, 1116 2006, 2001, 1, 0, 0, 0, 2007, 2010, 1, 0, 0, 0, 2008, 2006, 1, 0, 0, 0, 1117 2008, 2009, 1, 0, 0, 0, 2009, 163, 1, 0, 0, 0, 2010, 2008, 1, 0, 0, 0, 1118 2011, 2012, 3, 82, 41, 0, 2012, 165, 1, 0, 0, 0, 2013, 2014, 3, 82, 41, 1119 0, 2014, 167, 1, 0, 0, 0, 2015, 2016, 7, 25, 0, 0, 2016, 169, 1, 0, 0, 1120 0, 2017, 2018, 5, 188, 0, 0, 2018, 171, 1, 0, 0, 0, 2019, 2022, 3, 64, 1121 32, 0, 2020, 2022, 3, 28, 14, 0, 2021, 2019, 1, 0, 0, 0, 2021, 2020, 1, 1122 0, 0, 0, 2022, 173, 1, 0, 0, 0, 2023, 2024, 7, 26, 0, 0, 2024, 175, 1, 1123 0, 0, 0, 2025, 2026, 7, 27, 0, 0, 2026, 177, 1, 0, 0, 0, 2027, 2028, 3, 1124 224, 112, 0, 2028, 179, 1, 0, 0, 0, 2029, 2030, 3, 224, 112, 0, 2030, 181, 1125 1, 0, 0, 0, 2031, 2032, 3, 224, 112, 0, 2032, 183, 1, 0, 0, 0, 2033, 2034, 1126 3, 224, 112, 0, 2034, 185, 1, 0, 0, 0, 2035, 2036, 3, 224, 112, 0, 2036, 1127 187, 1, 0, 0, 0, 2037, 2038, 3, 224, 112, 0, 2038, 189, 1, 0, 0, 0, 2039, 1128 2040, 3, 224, 112, 0, 2040, 191, 1, 0, 0, 0, 2041, 2042, 3, 224, 112, 0, 1129 2042, 193, 1, 0, 0, 0, 2043, 2044, 3, 224, 112, 0, 2044, 195, 1, 0, 0, 1130 0, 2045, 2046, 3, 224, 112, 0, 2046, 197, 1, 0, 0, 0, 2047, 2048, 3, 224, 1131 112, 0, 2048, 199, 1, 0, 0, 0, 2049, 2050, 3, 224, 112, 0, 2050, 201, 1, 1132 0, 0, 0, 2051, 2052, 3, 224, 112, 0, 2052, 203, 1, 0, 0, 0, 2053, 2054, 1133 3, 224, 112, 0, 2054, 205, 1, 0, 0, 0, 2055, 2056, 3, 224, 112, 0, 2056, 1134 207, 1, 0, 0, 0, 2057, 2058, 3, 224, 112, 0, 2058, 209, 1, 0, 0, 0, 2059, 1135 2060, 3, 224, 112, 0, 2060, 211, 1, 0, 0, 0, 2061, 2062, 3, 224, 112, 0, 1136 2062, 213, 1, 0, 0, 0, 2063, 2064, 3, 224, 112, 0, 2064, 215, 1, 0, 0, 1137 0, 2065, 2066, 3, 224, 112, 0, 2066, 217, 1, 0, 0, 0, 2067, 2068, 3, 224, 1138 112, 0, 2068, 219, 1, 0, 0, 0, 2069, 2070, 3, 224, 112, 0, 2070, 221, 1, 1139 0, 0, 0, 2071, 2072, 3, 224, 112, 0, 2072, 223, 1, 0, 0, 0, 2073, 2081, 1140 5, 185, 0, 0, 2074, 2081, 3, 176, 88, 0, 2075, 2081, 5, 188, 0, 0, 2076, 1141 2077, 5, 3, 0, 0, 2077, 2078, 3, 224, 112, 0, 2078, 2079, 5, 4, 0, 0, 2079, 1142 2081, 1, 0, 0, 0, 2080, 2073, 1, 0, 0, 0, 2080, 2074, 1, 0, 0, 0, 2080, 1143 2075, 1, 0, 0, 0, 2080, 2076, 1, 0, 0, 0, 2081, 225, 1, 0, 0, 0, 297, 229, 1144 237, 244, 249, 255, 261, 263, 289, 296, 303, 309, 313, 318, 321, 328, 331, 1145 335, 343, 347, 349, 353, 357, 361, 364, 371, 377, 383, 388, 399, 405, 409, 1146 413, 416, 420, 426, 431, 440, 447, 453, 457, 461, 466, 472, 484, 488, 493, 1147 496, 499, 504, 507, 521, 528, 535, 537, 540, 546, 551, 559, 564, 579, 585, 1148 595, 600, 610, 614, 616, 620, 625, 627, 635, 641, 646, 653, 664, 667, 669, 1149 676, 680, 687, 693, 699, 705, 710, 719, 724, 735, 740, 751, 756, 760, 776, 1150 786, 791, 799, 811, 816, 824, 831, 834, 837, 844, 847, 850, 853, 857, 865, 1151 870, 880, 885, 894, 901, 905, 909, 912, 920, 933, 936, 944, 953, 957, 962, 1152 992, 1004, 1009, 1021, 1027, 1034, 1038, 1048, 1051, 1057, 1063, 1072, 1153 1075, 1079, 1081, 1083, 1092, 1099, 1106, 1112, 1117, 1125, 1130, 1139, 1154 1150, 1157, 1161, 1164, 1168, 1171, 1179, 1190, 1196, 1198, 1206, 1213, 1155 1220, 1225, 1227, 1233, 1242, 1247, 1254, 1258, 1260, 1263, 1271, 1275, 1156 1278, 1284, 1288, 1293, 1300, 1309, 1313, 1315, 1319, 1328, 1333, 1335, 1157 1348, 1351, 1360, 1371, 1378, 1381, 1386, 1390, 1393, 1396, 1401, 1405, 1158 1410, 1413, 1416, 1421, 1425, 1428, 1435, 1440, 1449, 1454, 1457, 1465, 1159 1469, 1477, 1480, 1482, 1491, 1494, 1496, 1500, 1504, 1508, 1511, 1522, 1160 1527, 1531, 1535, 1538, 1543, 1554, 1558, 1560, 1564, 1567, 1574, 1579, 1161 1590, 1596, 1601, 1607, 1614, 1621, 1626, 1629, 1632, 1635, 1640, 1645, 1162 1652, 1656, 1660, 1670, 1679, 1682, 1691, 1695, 1703, 1712, 1715, 1724, 1163 1727, 1730, 1733, 1743, 1752, 1761, 1765, 1772, 1779, 1783, 1787, 1796, 1164 1800, 1804, 1809, 1813, 1820, 1830, 1837, 1842, 1845, 1849, 1863, 1875, 1165 1884, 1893, 1897, 1907, 1910, 1919, 1928, 1931, 1937, 1951, 1955, 1966, 1166 1971, 1984, 1991, 1999, 2004, 2008, 2021, 2080, 1167 } 1168 deserializer := antlr.NewATNDeserializer(nil) 1169 staticData.atn = deserializer.Deserialize(staticData.serializedATN) 1170 atn := staticData.atn 1171 staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState)) 1172 decisionToDFA := staticData.decisionToDFA 1173 for index, state := range atn.DecisionToState { 1174 decisionToDFA[index] = antlr.NewDFA(state, index) 1175 } 1176 } 1177 1178 // ParserInit initializes any static state used to implement Parser. By default the 1179 // static state used to implement the parser is lazily initialized during the first call to 1180 // NewParser(). You can call this function if you wish to initialize the static state ahead 1181 // of time. 1182 func ParserInit() { 1183 staticData := &parserParserStaticData 1184 staticData.once.Do(parserParserInit) 1185 } 1186 1187 // NewParser produces a new parser instance for the optional input antlr.TokenStream. 1188 func NewParser(input antlr.TokenStream) *Parser { 1189 ParserInit() 1190 this := new(Parser) 1191 this.BaseParser = antlr.NewBaseParser(input) 1192 staticData := &parserParserStaticData 1193 this.Interpreter = antlr.NewParserATNSimulator(this, staticData.atn, staticData.decisionToDFA, staticData.predictionContextCache) 1194 this.RuleNames = staticData.ruleNames 1195 this.LiteralNames = staticData.literalNames 1196 this.SymbolicNames = staticData.symbolicNames 1197 this.GrammarFileName = "Parser.g4" 1198 1199 return this 1200 } 1201 1202 // Parser tokens. 1203 const ( 1204 ParserEOF = antlr.TokenEOF 1205 ParserSCOL = 1 1206 ParserDOT = 2 1207 ParserOPEN_PAR = 3 1208 ParserCLOSE_PAR = 4 1209 ParserCOMMA = 5 1210 ParserASSIGN = 6 1211 ParserSTAR = 7 1212 ParserPLUS = 8 1213 ParserMINUS = 9 1214 ParserTILDE = 10 1215 ParserPIPE2 = 11 1216 ParserDIV = 12 1217 ParserMOD = 13 1218 ParserLT2 = 14 1219 ParserGT2 = 15 1220 ParserAMP = 16 1221 ParserPIPE = 17 1222 ParserLT = 18 1223 ParserLT_EQ = 19 1224 ParserGT = 20 1225 ParserGT_EQ = 21 1226 ParserEQ = 22 1227 ParserNOT_EQ1 = 23 1228 ParserNOT_EQ2 = 24 1229 ParserABORT_ = 25 1230 ParserACTION_ = 26 1231 ParserADD_ = 27 1232 ParserAFTER_ = 28 1233 ParserALL_ = 29 1234 ParserALTER_ = 30 1235 ParserANALYZE_ = 31 1236 ParserAND_ = 32 1237 ParserAS_ = 33 1238 ParserASC_ = 34 1239 ParserATTACH_ = 35 1240 ParserAUTOINCREMENT_ = 36 1241 ParserBEFORE_ = 37 1242 ParserBEGIN_ = 38 1243 ParserBETWEEN_ = 39 1244 ParserBY_ = 40 1245 ParserCASCADE_ = 41 1246 ParserCASE_ = 42 1247 ParserCAST_ = 43 1248 ParserCHECK_ = 44 1249 ParserCOLLATE_ = 45 1250 ParserCOLUMN_ = 46 1251 ParserCOMMIT_ = 47 1252 ParserCONFLICT_ = 48 1253 ParserCONSTRAINT_ = 49 1254 ParserCREATE_ = 50 1255 ParserCROSS_ = 51 1256 ParserCURRENT_DATE_ = 52 1257 ParserCURRENT_TIME_ = 53 1258 ParserCURRENT_TIMESTAMP_ = 54 1259 ParserDATABASE_ = 55 1260 ParserDEFAULT_ = 56 1261 ParserDEFERRABLE_ = 57 1262 ParserDEFERRED_ = 58 1263 ParserDELETE_ = 59 1264 ParserDESC_ = 60 1265 ParserDETACH_ = 61 1266 ParserDISTINCT_ = 62 1267 ParserDROP_ = 63 1268 ParserEACH_ = 64 1269 ParserELSE_ = 65 1270 ParserEND_ = 66 1271 ParserESCAPE_ = 67 1272 ParserEXCEPT_ = 68 1273 ParserEXCLUSIVE_ = 69 1274 ParserEXISTS_ = 70 1275 ParserEXPLAIN_ = 71 1276 ParserFAIL_ = 72 1277 ParserFOR_ = 73 1278 ParserFOREIGN_ = 74 1279 ParserFROM_ = 75 1280 ParserFULL_ = 76 1281 ParserGLOB_ = 77 1282 ParserGROUP_ = 78 1283 ParserHAVING_ = 79 1284 ParserIF_ = 80 1285 ParserIGNORE_ = 81 1286 ParserIMMEDIATE_ = 82 1287 ParserIN_ = 83 1288 ParserINDEX_ = 84 1289 ParserINDEXED_ = 85 1290 ParserINITIALLY_ = 86 1291 ParserINNER_ = 87 1292 ParserINSERT_ = 88 1293 ParserINSTEAD_ = 89 1294 ParserINTERSECT_ = 90 1295 ParserINTO_ = 91 1296 ParserIS_ = 92 1297 ParserISNULL_ = 93 1298 ParserJOIN_ = 94 1299 ParserKEY_ = 95 1300 ParserLEFT_ = 96 1301 ParserLIKE_ = 97 1302 ParserLIMIT_ = 98 1303 ParserMATCH_ = 99 1304 ParserNATURAL_ = 100 1305 ParserNO_ = 101 1306 ParserNOT_ = 102 1307 ParserNOTNULL_ = 103 1308 ParserNULL_ = 104 1309 ParserOF_ = 105 1310 ParserOFFSET_ = 106 1311 ParserON_ = 107 1312 ParserOR_ = 108 1313 ParserORDER_ = 109 1314 ParserOUTER_ = 110 1315 ParserPLAN_ = 111 1316 ParserPRAGMA_ = 112 1317 ParserPRIMARY_ = 113 1318 ParserQUERY_ = 114 1319 ParserRAISE_ = 115 1320 ParserRECURSIVE_ = 116 1321 ParserREFERENCES_ = 117 1322 ParserREGEXP_ = 118 1323 ParserREINDEX_ = 119 1324 ParserRELEASE_ = 120 1325 ParserRENAME_ = 121 1326 ParserREPLACE_ = 122 1327 ParserRESTRICT_ = 123 1328 ParserRETURNING_ = 124 1329 ParserRIGHT_ = 125 1330 ParserROLLBACK_ = 126 1331 ParserROW_ = 127 1332 ParserROWS_ = 128 1333 ParserSAVEPOINT_ = 129 1334 ParserSELECT_ = 130 1335 ParserSET_ = 131 1336 ParserTABLE_ = 132 1337 ParserTEMP_ = 133 1338 ParserTEMPORARY_ = 134 1339 ParserTHEN_ = 135 1340 ParserTO_ = 136 1341 ParserTRANSACTION_ = 137 1342 ParserTRIGGER_ = 138 1343 ParserUNION_ = 139 1344 ParserUNIQUE_ = 140 1345 ParserUPDATE_ = 141 1346 ParserUSING_ = 142 1347 ParserVACUUM_ = 143 1348 ParserVALUES_ = 144 1349 ParserVIEW_ = 145 1350 ParserVIRTUAL_ = 146 1351 ParserWHEN_ = 147 1352 ParserWHERE_ = 148 1353 ParserWITH_ = 149 1354 ParserWITHOUT_ = 150 1355 ParserFIRST_VALUE_ = 151 1356 ParserOVER_ = 152 1357 ParserPARTITION_ = 153 1358 ParserRANGE_ = 154 1359 ParserPRECEDING_ = 155 1360 ParserUNBOUNDED_ = 156 1361 ParserCURRENT_ = 157 1362 ParserFOLLOWING_ = 158 1363 ParserCUME_DIST_ = 159 1364 ParserDENSE_RANK_ = 160 1365 ParserLAG_ = 161 1366 ParserLAST_VALUE_ = 162 1367 ParserLEAD_ = 163 1368 ParserNTH_VALUE_ = 164 1369 ParserNTILE_ = 165 1370 ParserPERCENT_RANK_ = 166 1371 ParserRANK_ = 167 1372 ParserROW_NUMBER_ = 168 1373 ParserGENERATED_ = 169 1374 ParserALWAYS_ = 170 1375 ParserSTORED_ = 171 1376 ParserTRUE_ = 172 1377 ParserFALSE_ = 173 1378 ParserWINDOW_ = 174 1379 ParserNULLS_ = 175 1380 ParserFIRST_ = 176 1381 ParserLAST_ = 177 1382 ParserFILTER_ = 178 1383 ParserGROUPS_ = 179 1384 ParserEXCLUDE_ = 180 1385 ParserTIES_ = 181 1386 ParserOTHERS_ = 182 1387 ParserDO_ = 183 1388 ParserNOTHING_ = 184 1389 ParserIDENTIFIER = 185 1390 ParserNUMERIC_LITERAL = 186 1391 ParserBIND_PARAMETER = 187 1392 ParserSTRING_LITERAL = 188 1393 ParserBLOB_LITERAL = 189 1394 ParserSINGLE_LINE_COMMENT = 190 1395 ParserMULTILINE_COMMENT = 191 1396 ParserSPACES = 192 1397 ParserUNEXPECTED_CHAR = 193 1398 ) 1399 1400 // Parser rules. 1401 const ( 1402 ParserRULE_parse = 0 1403 ParserRULE_sql_stmt_list = 1 1404 ParserRULE_sql_stmt = 2 1405 ParserRULE_alter_table_stmt = 3 1406 ParserRULE_analyze_stmt = 4 1407 ParserRULE_attach_stmt = 5 1408 ParserRULE_begin_stmt = 6 1409 ParserRULE_commit_stmt = 7 1410 ParserRULE_rollback_stmt = 8 1411 ParserRULE_savepoint_stmt = 9 1412 ParserRULE_release_stmt = 10 1413 ParserRULE_create_index_stmt = 11 1414 ParserRULE_indexed_column = 12 1415 ParserRULE_create_table_stmt = 13 1416 ParserRULE_column_def = 14 1417 ParserRULE_type_name = 15 1418 ParserRULE_column_constraint = 16 1419 ParserRULE_signed_number = 17 1420 ParserRULE_table_constraint = 18 1421 ParserRULE_foreign_key_clause = 19 1422 ParserRULE_conflict_clause = 20 1423 ParserRULE_create_trigger_stmt = 21 1424 ParserRULE_create_view_stmt = 22 1425 ParserRULE_create_virtual_table_stmt = 23 1426 ParserRULE_with_clause = 24 1427 ParserRULE_cte_table_name = 25 1428 ParserRULE_recursive_cte = 26 1429 ParserRULE_common_table_expression = 27 1430 ParserRULE_delete_stmt = 28 1431 ParserRULE_delete_stmt_limited = 29 1432 ParserRULE_detach_stmt = 30 1433 ParserRULE_drop_stmt = 31 1434 ParserRULE_expr = 32 1435 ParserRULE_raise_function = 33 1436 ParserRULE_literal_value = 34 1437 ParserRULE_insert_stmt = 35 1438 ParserRULE_returning_clause = 36 1439 ParserRULE_upsert_clause = 37 1440 ParserRULE_pragma_stmt = 38 1441 ParserRULE_pragma_value = 39 1442 ParserRULE_reindex_stmt = 40 1443 ParserRULE_select_stmt = 41 1444 ParserRULE_join_clause = 42 1445 ParserRULE_select_core = 43 1446 ParserRULE_factored_select_stmt = 44 1447 ParserRULE_simple_select_stmt = 45 1448 ParserRULE_compound_select_stmt = 46 1449 ParserRULE_table_or_subquery = 47 1450 ParserRULE_result_column = 48 1451 ParserRULE_join_operator = 49 1452 ParserRULE_join_constraint = 50 1453 ParserRULE_compound_operator = 51 1454 ParserRULE_update_stmt = 52 1455 ParserRULE_assignment_list = 53 1456 ParserRULE_assignment = 54 1457 ParserRULE_column_name_list = 55 1458 ParserRULE_update_stmt_limited = 56 1459 ParserRULE_qualified_table_name = 57 1460 ParserRULE_vacuum_stmt = 58 1461 ParserRULE_filter_clause = 59 1462 ParserRULE_window_defn = 60 1463 ParserRULE_over_clause = 61 1464 ParserRULE_frame_spec = 62 1465 ParserRULE_frame_clause = 63 1466 ParserRULE_simple_function_invocation = 64 1467 ParserRULE_aggregate_function_invocation = 65 1468 ParserRULE_window_function_invocation = 66 1469 ParserRULE_common_table_stmt = 67 1470 ParserRULE_order_by_stmt = 68 1471 ParserRULE_limit_stmt = 69 1472 ParserRULE_ordering_term = 70 1473 ParserRULE_asc_desc = 71 1474 ParserRULE_frame_left = 72 1475 ParserRULE_frame_right = 73 1476 ParserRULE_frame_single = 74 1477 ParserRULE_window_function = 75 1478 ParserRULE_offset = 76 1479 ParserRULE_default_value = 77 1480 ParserRULE_partition_by = 78 1481 ParserRULE_order_by_expr = 79 1482 ParserRULE_order_by_expr_asc_desc = 80 1483 ParserRULE_expr_asc_desc = 81 1484 ParserRULE_initial_select = 82 1485 ParserRULE_recursive_select = 83 1486 ParserRULE_unary_operator = 84 1487 ParserRULE_error_message = 85 1488 ParserRULE_module_argument = 86 1489 ParserRULE_column_alias = 87 1490 ParserRULE_keyword = 88 1491 ParserRULE_name = 89 1492 ParserRULE_function_name = 90 1493 ParserRULE_schema_name = 91 1494 ParserRULE_table_name = 92 1495 ParserRULE_table_or_index_name = 93 1496 ParserRULE_column_name = 94 1497 ParserRULE_collation_name = 95 1498 ParserRULE_foreign_table = 96 1499 ParserRULE_index_name = 97 1500 ParserRULE_trigger_name = 98 1501 ParserRULE_view_name = 99 1502 ParserRULE_module_name = 100 1503 ParserRULE_pragma_name = 101 1504 ParserRULE_savepoint_name = 102 1505 ParserRULE_table_alias = 103 1506 ParserRULE_transaction_name = 104 1507 ParserRULE_window_name = 105 1508 ParserRULE_alias = 106 1509 ParserRULE_filename = 107 1510 ParserRULE_base_window_name = 108 1511 ParserRULE_simple_func = 109 1512 ParserRULE_aggregate_func = 110 1513 ParserRULE_table_function_name = 111 1514 ParserRULE_any_name = 112 1515 ) 1516 1517 // IParseContext is an interface to support dynamic dispatch. 1518 type IParseContext interface { 1519 antlr.ParserRuleContext 1520 1521 // GetParser returns the parser. 1522 GetParser() antlr.Parser 1523 1524 // IsParseContext differentiates from other interfaces. 1525 IsParseContext() 1526 } 1527 1528 type ParseContext struct { 1529 *antlr.BaseParserRuleContext 1530 parser antlr.Parser 1531 } 1532 1533 func NewEmptyParseContext() *ParseContext { 1534 var p = new(ParseContext) 1535 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 1536 p.RuleIndex = ParserRULE_parse 1537 return p 1538 } 1539 1540 func (*ParseContext) IsParseContext() {} 1541 1542 func NewParseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParseContext { 1543 var p = new(ParseContext) 1544 1545 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 1546 1547 p.parser = parser 1548 p.RuleIndex = ParserRULE_parse 1549 1550 return p 1551 } 1552 1553 func (s *ParseContext) GetParser() antlr.Parser { return s.parser } 1554 1555 func (s *ParseContext) EOF() antlr.TerminalNode { 1556 return s.GetToken(ParserEOF, 0) 1557 } 1558 1559 func (s *ParseContext) AllSql_stmt_list() []ISql_stmt_listContext { 1560 children := s.GetChildren() 1561 len := 0 1562 for _, ctx := range children { 1563 if _, ok := ctx.(ISql_stmt_listContext); ok { 1564 len++ 1565 } 1566 } 1567 1568 tst := make([]ISql_stmt_listContext, len) 1569 i := 0 1570 for _, ctx := range children { 1571 if t, ok := ctx.(ISql_stmt_listContext); ok { 1572 tst[i] = t.(ISql_stmt_listContext) 1573 i++ 1574 } 1575 } 1576 1577 return tst 1578 } 1579 1580 func (s *ParseContext) Sql_stmt_list(i int) ISql_stmt_listContext { 1581 var t antlr.RuleContext 1582 j := 0 1583 for _, ctx := range s.GetChildren() { 1584 if _, ok := ctx.(ISql_stmt_listContext); ok { 1585 if j == i { 1586 t = ctx.(antlr.RuleContext) 1587 break 1588 } 1589 j++ 1590 } 1591 } 1592 1593 if t == nil { 1594 return nil 1595 } 1596 1597 return t.(ISql_stmt_listContext) 1598 } 1599 1600 func (s *ParseContext) GetRuleContext() antlr.RuleContext { 1601 return s 1602 } 1603 1604 func (s *ParseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 1605 return antlr.TreesStringTree(s, ruleNames, recog) 1606 } 1607 1608 func (s *ParseContext) EnterRule(listener antlr.ParseTreeListener) { 1609 if listenerT, ok := listener.(ParserListener); ok { 1610 listenerT.EnterParse(s) 1611 } 1612 } 1613 1614 func (s *ParseContext) ExitRule(listener antlr.ParseTreeListener) { 1615 if listenerT, ok := listener.(ParserListener); ok { 1616 listenerT.ExitParse(s) 1617 } 1618 } 1619 1620 func (s *ParseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 1621 switch t := visitor.(type) { 1622 case ParserVisitor: 1623 return t.VisitParse(s) 1624 1625 default: 1626 return t.VisitChildren(s) 1627 } 1628 } 1629 1630 func (p *Parser) Parse() (localctx IParseContext) { 1631 this := p 1632 _ = this 1633 1634 localctx = NewParseContext(p, p.GetParserRuleContext(), p.GetState()) 1635 p.EnterRule(localctx, 0, ParserRULE_parse) 1636 var _la int 1637 1638 defer func() { 1639 p.ExitRule() 1640 }() 1641 1642 defer func() { 1643 if err := recover(); err != nil { 1644 if v, ok := err.(antlr.RecognitionException); ok { 1645 localctx.SetException(v) 1646 p.GetErrorHandler().ReportError(p, v) 1647 p.GetErrorHandler().Recover(p, v) 1648 } else { 1649 panic(err) 1650 } 1651 } 1652 }() 1653 1654 p.EnterOuterAlt(localctx, 1) 1655 p.SetState(229) 1656 p.GetErrorHandler().Sync(p) 1657 _la = p.GetTokenStream().LA(1) 1658 1659 for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<ParserSCOL)|(1<<ParserALTER_)|(1<<ParserANALYZE_))) != 0) || (((_la-35)&-(0x1f+1)) == 0 && ((1<<uint((_la-35)))&((1<<(ParserATTACH_-35))|(1<<(ParserBEGIN_-35))|(1<<(ParserCOMMIT_-35))|(1<<(ParserCREATE_-35))|(1<<(ParserDELETE_-35))|(1<<(ParserDETACH_-35))|(1<<(ParserDROP_-35))|(1<<(ParserEND_-35)))) != 0) || _la == ParserEXPLAIN_ || _la == ParserINSERT_ || (((_la-112)&-(0x1f+1)) == 0 && ((1<<uint((_la-112)))&((1<<(ParserPRAGMA_-112))|(1<<(ParserREINDEX_-112))|(1<<(ParserRELEASE_-112))|(1<<(ParserREPLACE_-112))|(1<<(ParserROLLBACK_-112))|(1<<(ParserSAVEPOINT_-112))|(1<<(ParserSELECT_-112))|(1<<(ParserUPDATE_-112))|(1<<(ParserVACUUM_-112)))) != 0) || _la == ParserVALUES_ || _la == ParserWITH_ { 1660 { 1661 p.SetState(226) 1662 p.Sql_stmt_list() 1663 } 1664 1665 p.SetState(231) 1666 p.GetErrorHandler().Sync(p) 1667 _la = p.GetTokenStream().LA(1) 1668 } 1669 { 1670 p.SetState(232) 1671 p.Match(ParserEOF) 1672 } 1673 1674 return localctx 1675 } 1676 1677 // ISql_stmt_listContext is an interface to support dynamic dispatch. 1678 type ISql_stmt_listContext interface { 1679 antlr.ParserRuleContext 1680 1681 // GetParser returns the parser. 1682 GetParser() antlr.Parser 1683 1684 // IsSql_stmt_listContext differentiates from other interfaces. 1685 IsSql_stmt_listContext() 1686 } 1687 1688 type Sql_stmt_listContext struct { 1689 *antlr.BaseParserRuleContext 1690 parser antlr.Parser 1691 } 1692 1693 func NewEmptySql_stmt_listContext() *Sql_stmt_listContext { 1694 var p = new(Sql_stmt_listContext) 1695 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 1696 p.RuleIndex = ParserRULE_sql_stmt_list 1697 return p 1698 } 1699 1700 func (*Sql_stmt_listContext) IsSql_stmt_listContext() {} 1701 1702 func NewSql_stmt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_stmt_listContext { 1703 var p = new(Sql_stmt_listContext) 1704 1705 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 1706 1707 p.parser = parser 1708 p.RuleIndex = ParserRULE_sql_stmt_list 1709 1710 return p 1711 } 1712 1713 func (s *Sql_stmt_listContext) GetParser() antlr.Parser { return s.parser } 1714 1715 func (s *Sql_stmt_listContext) AllSql_stmt() []ISql_stmtContext { 1716 children := s.GetChildren() 1717 len := 0 1718 for _, ctx := range children { 1719 if _, ok := ctx.(ISql_stmtContext); ok { 1720 len++ 1721 } 1722 } 1723 1724 tst := make([]ISql_stmtContext, len) 1725 i := 0 1726 for _, ctx := range children { 1727 if t, ok := ctx.(ISql_stmtContext); ok { 1728 tst[i] = t.(ISql_stmtContext) 1729 i++ 1730 } 1731 } 1732 1733 return tst 1734 } 1735 1736 func (s *Sql_stmt_listContext) Sql_stmt(i int) ISql_stmtContext { 1737 var t antlr.RuleContext 1738 j := 0 1739 for _, ctx := range s.GetChildren() { 1740 if _, ok := ctx.(ISql_stmtContext); ok { 1741 if j == i { 1742 t = ctx.(antlr.RuleContext) 1743 break 1744 } 1745 j++ 1746 } 1747 } 1748 1749 if t == nil { 1750 return nil 1751 } 1752 1753 return t.(ISql_stmtContext) 1754 } 1755 1756 func (s *Sql_stmt_listContext) AllSCOL() []antlr.TerminalNode { 1757 return s.GetTokens(ParserSCOL) 1758 } 1759 1760 func (s *Sql_stmt_listContext) SCOL(i int) antlr.TerminalNode { 1761 return s.GetToken(ParserSCOL, i) 1762 } 1763 1764 func (s *Sql_stmt_listContext) GetRuleContext() antlr.RuleContext { 1765 return s 1766 } 1767 1768 func (s *Sql_stmt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 1769 return antlr.TreesStringTree(s, ruleNames, recog) 1770 } 1771 1772 func (s *Sql_stmt_listContext) EnterRule(listener antlr.ParseTreeListener) { 1773 if listenerT, ok := listener.(ParserListener); ok { 1774 listenerT.EnterSql_stmt_list(s) 1775 } 1776 } 1777 1778 func (s *Sql_stmt_listContext) ExitRule(listener antlr.ParseTreeListener) { 1779 if listenerT, ok := listener.(ParserListener); ok { 1780 listenerT.ExitSql_stmt_list(s) 1781 } 1782 } 1783 1784 func (s *Sql_stmt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 1785 switch t := visitor.(type) { 1786 case ParserVisitor: 1787 return t.VisitSql_stmt_list(s) 1788 1789 default: 1790 return t.VisitChildren(s) 1791 } 1792 } 1793 1794 func (p *Parser) Sql_stmt_list() (localctx ISql_stmt_listContext) { 1795 this := p 1796 _ = this 1797 1798 localctx = NewSql_stmt_listContext(p, p.GetParserRuleContext(), p.GetState()) 1799 p.EnterRule(localctx, 2, ParserRULE_sql_stmt_list) 1800 var _la int 1801 1802 defer func() { 1803 p.ExitRule() 1804 }() 1805 1806 defer func() { 1807 if err := recover(); err != nil { 1808 if v, ok := err.(antlr.RecognitionException); ok { 1809 localctx.SetException(v) 1810 p.GetErrorHandler().ReportError(p, v) 1811 p.GetErrorHandler().Recover(p, v) 1812 } else { 1813 panic(err) 1814 } 1815 } 1816 }() 1817 1818 var _alt int 1819 1820 p.EnterOuterAlt(localctx, 1) 1821 p.SetState(237) 1822 p.GetErrorHandler().Sync(p) 1823 _la = p.GetTokenStream().LA(1) 1824 1825 for _la == ParserSCOL { 1826 { 1827 p.SetState(234) 1828 p.Match(ParserSCOL) 1829 } 1830 1831 p.SetState(239) 1832 p.GetErrorHandler().Sync(p) 1833 _la = p.GetTokenStream().LA(1) 1834 } 1835 { 1836 p.SetState(240) 1837 p.Sql_stmt() 1838 } 1839 p.SetState(249) 1840 p.GetErrorHandler().Sync(p) 1841 _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 3, p.GetParserRuleContext()) 1842 1843 for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { 1844 if _alt == 1 { 1845 p.SetState(242) 1846 p.GetErrorHandler().Sync(p) 1847 _la = p.GetTokenStream().LA(1) 1848 1849 for ok := true; ok; ok = _la == ParserSCOL { 1850 { 1851 p.SetState(241) 1852 p.Match(ParserSCOL) 1853 } 1854 1855 p.SetState(244) 1856 p.GetErrorHandler().Sync(p) 1857 _la = p.GetTokenStream().LA(1) 1858 } 1859 { 1860 p.SetState(246) 1861 p.Sql_stmt() 1862 } 1863 1864 } 1865 p.SetState(251) 1866 p.GetErrorHandler().Sync(p) 1867 _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 3, p.GetParserRuleContext()) 1868 } 1869 p.SetState(255) 1870 p.GetErrorHandler().Sync(p) 1871 _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 4, p.GetParserRuleContext()) 1872 1873 for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { 1874 if _alt == 1 { 1875 { 1876 p.SetState(252) 1877 p.Match(ParserSCOL) 1878 } 1879 1880 } 1881 p.SetState(257) 1882 p.GetErrorHandler().Sync(p) 1883 _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 4, p.GetParserRuleContext()) 1884 } 1885 1886 return localctx 1887 } 1888 1889 // ISql_stmtContext is an interface to support dynamic dispatch. 1890 type ISql_stmtContext interface { 1891 antlr.ParserRuleContext 1892 1893 // GetParser returns the parser. 1894 GetParser() antlr.Parser 1895 1896 // IsSql_stmtContext differentiates from other interfaces. 1897 IsSql_stmtContext() 1898 } 1899 1900 type Sql_stmtContext struct { 1901 *antlr.BaseParserRuleContext 1902 parser antlr.Parser 1903 } 1904 1905 func NewEmptySql_stmtContext() *Sql_stmtContext { 1906 var p = new(Sql_stmtContext) 1907 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 1908 p.RuleIndex = ParserRULE_sql_stmt 1909 return p 1910 } 1911 1912 func (*Sql_stmtContext) IsSql_stmtContext() {} 1913 1914 func NewSql_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_stmtContext { 1915 var p = new(Sql_stmtContext) 1916 1917 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 1918 1919 p.parser = parser 1920 p.RuleIndex = ParserRULE_sql_stmt 1921 1922 return p 1923 } 1924 1925 func (s *Sql_stmtContext) GetParser() antlr.Parser { return s.parser } 1926 1927 func (s *Sql_stmtContext) Alter_table_stmt() IAlter_table_stmtContext { 1928 var t antlr.RuleContext 1929 for _, ctx := range s.GetChildren() { 1930 if _, ok := ctx.(IAlter_table_stmtContext); ok { 1931 t = ctx.(antlr.RuleContext) 1932 break 1933 } 1934 } 1935 1936 if t == nil { 1937 return nil 1938 } 1939 1940 return t.(IAlter_table_stmtContext) 1941 } 1942 1943 func (s *Sql_stmtContext) Analyze_stmt() IAnalyze_stmtContext { 1944 var t antlr.RuleContext 1945 for _, ctx := range s.GetChildren() { 1946 if _, ok := ctx.(IAnalyze_stmtContext); ok { 1947 t = ctx.(antlr.RuleContext) 1948 break 1949 } 1950 } 1951 1952 if t == nil { 1953 return nil 1954 } 1955 1956 return t.(IAnalyze_stmtContext) 1957 } 1958 1959 func (s *Sql_stmtContext) Attach_stmt() IAttach_stmtContext { 1960 var t antlr.RuleContext 1961 for _, ctx := range s.GetChildren() { 1962 if _, ok := ctx.(IAttach_stmtContext); ok { 1963 t = ctx.(antlr.RuleContext) 1964 break 1965 } 1966 } 1967 1968 if t == nil { 1969 return nil 1970 } 1971 1972 return t.(IAttach_stmtContext) 1973 } 1974 1975 func (s *Sql_stmtContext) Begin_stmt() IBegin_stmtContext { 1976 var t antlr.RuleContext 1977 for _, ctx := range s.GetChildren() { 1978 if _, ok := ctx.(IBegin_stmtContext); ok { 1979 t = ctx.(antlr.RuleContext) 1980 break 1981 } 1982 } 1983 1984 if t == nil { 1985 return nil 1986 } 1987 1988 return t.(IBegin_stmtContext) 1989 } 1990 1991 func (s *Sql_stmtContext) Commit_stmt() ICommit_stmtContext { 1992 var t antlr.RuleContext 1993 for _, ctx := range s.GetChildren() { 1994 if _, ok := ctx.(ICommit_stmtContext); ok { 1995 t = ctx.(antlr.RuleContext) 1996 break 1997 } 1998 } 1999 2000 if t == nil { 2001 return nil 2002 } 2003 2004 return t.(ICommit_stmtContext) 2005 } 2006 2007 func (s *Sql_stmtContext) Create_index_stmt() ICreate_index_stmtContext { 2008 var t antlr.RuleContext 2009 for _, ctx := range s.GetChildren() { 2010 if _, ok := ctx.(ICreate_index_stmtContext); ok { 2011 t = ctx.(antlr.RuleContext) 2012 break 2013 } 2014 } 2015 2016 if t == nil { 2017 return nil 2018 } 2019 2020 return t.(ICreate_index_stmtContext) 2021 } 2022 2023 func (s *Sql_stmtContext) Create_table_stmt() ICreate_table_stmtContext { 2024 var t antlr.RuleContext 2025 for _, ctx := range s.GetChildren() { 2026 if _, ok := ctx.(ICreate_table_stmtContext); ok { 2027 t = ctx.(antlr.RuleContext) 2028 break 2029 } 2030 } 2031 2032 if t == nil { 2033 return nil 2034 } 2035 2036 return t.(ICreate_table_stmtContext) 2037 } 2038 2039 func (s *Sql_stmtContext) Create_trigger_stmt() ICreate_trigger_stmtContext { 2040 var t antlr.RuleContext 2041 for _, ctx := range s.GetChildren() { 2042 if _, ok := ctx.(ICreate_trigger_stmtContext); ok { 2043 t = ctx.(antlr.RuleContext) 2044 break 2045 } 2046 } 2047 2048 if t == nil { 2049 return nil 2050 } 2051 2052 return t.(ICreate_trigger_stmtContext) 2053 } 2054 2055 func (s *Sql_stmtContext) Create_view_stmt() ICreate_view_stmtContext { 2056 var t antlr.RuleContext 2057 for _, ctx := range s.GetChildren() { 2058 if _, ok := ctx.(ICreate_view_stmtContext); ok { 2059 t = ctx.(antlr.RuleContext) 2060 break 2061 } 2062 } 2063 2064 if t == nil { 2065 return nil 2066 } 2067 2068 return t.(ICreate_view_stmtContext) 2069 } 2070 2071 func (s *Sql_stmtContext) Create_virtual_table_stmt() ICreate_virtual_table_stmtContext { 2072 var t antlr.RuleContext 2073 for _, ctx := range s.GetChildren() { 2074 if _, ok := ctx.(ICreate_virtual_table_stmtContext); ok { 2075 t = ctx.(antlr.RuleContext) 2076 break 2077 } 2078 } 2079 2080 if t == nil { 2081 return nil 2082 } 2083 2084 return t.(ICreate_virtual_table_stmtContext) 2085 } 2086 2087 func (s *Sql_stmtContext) Delete_stmt() IDelete_stmtContext { 2088 var t antlr.RuleContext 2089 for _, ctx := range s.GetChildren() { 2090 if _, ok := ctx.(IDelete_stmtContext); ok { 2091 t = ctx.(antlr.RuleContext) 2092 break 2093 } 2094 } 2095 2096 if t == nil { 2097 return nil 2098 } 2099 2100 return t.(IDelete_stmtContext) 2101 } 2102 2103 func (s *Sql_stmtContext) Delete_stmt_limited() IDelete_stmt_limitedContext { 2104 var t antlr.RuleContext 2105 for _, ctx := range s.GetChildren() { 2106 if _, ok := ctx.(IDelete_stmt_limitedContext); ok { 2107 t = ctx.(antlr.RuleContext) 2108 break 2109 } 2110 } 2111 2112 if t == nil { 2113 return nil 2114 } 2115 2116 return t.(IDelete_stmt_limitedContext) 2117 } 2118 2119 func (s *Sql_stmtContext) Detach_stmt() IDetach_stmtContext { 2120 var t antlr.RuleContext 2121 for _, ctx := range s.GetChildren() { 2122 if _, ok := ctx.(IDetach_stmtContext); ok { 2123 t = ctx.(antlr.RuleContext) 2124 break 2125 } 2126 } 2127 2128 if t == nil { 2129 return nil 2130 } 2131 2132 return t.(IDetach_stmtContext) 2133 } 2134 2135 func (s *Sql_stmtContext) Drop_stmt() IDrop_stmtContext { 2136 var t antlr.RuleContext 2137 for _, ctx := range s.GetChildren() { 2138 if _, ok := ctx.(IDrop_stmtContext); ok { 2139 t = ctx.(antlr.RuleContext) 2140 break 2141 } 2142 } 2143 2144 if t == nil { 2145 return nil 2146 } 2147 2148 return t.(IDrop_stmtContext) 2149 } 2150 2151 func (s *Sql_stmtContext) Insert_stmt() IInsert_stmtContext { 2152 var t antlr.RuleContext 2153 for _, ctx := range s.GetChildren() { 2154 if _, ok := ctx.(IInsert_stmtContext); ok { 2155 t = ctx.(antlr.RuleContext) 2156 break 2157 } 2158 } 2159 2160 if t == nil { 2161 return nil 2162 } 2163 2164 return t.(IInsert_stmtContext) 2165 } 2166 2167 func (s *Sql_stmtContext) Pragma_stmt() IPragma_stmtContext { 2168 var t antlr.RuleContext 2169 for _, ctx := range s.GetChildren() { 2170 if _, ok := ctx.(IPragma_stmtContext); ok { 2171 t = ctx.(antlr.RuleContext) 2172 break 2173 } 2174 } 2175 2176 if t == nil { 2177 return nil 2178 } 2179 2180 return t.(IPragma_stmtContext) 2181 } 2182 2183 func (s *Sql_stmtContext) Reindex_stmt() IReindex_stmtContext { 2184 var t antlr.RuleContext 2185 for _, ctx := range s.GetChildren() { 2186 if _, ok := ctx.(IReindex_stmtContext); ok { 2187 t = ctx.(antlr.RuleContext) 2188 break 2189 } 2190 } 2191 2192 if t == nil { 2193 return nil 2194 } 2195 2196 return t.(IReindex_stmtContext) 2197 } 2198 2199 func (s *Sql_stmtContext) Release_stmt() IRelease_stmtContext { 2200 var t antlr.RuleContext 2201 for _, ctx := range s.GetChildren() { 2202 if _, ok := ctx.(IRelease_stmtContext); ok { 2203 t = ctx.(antlr.RuleContext) 2204 break 2205 } 2206 } 2207 2208 if t == nil { 2209 return nil 2210 } 2211 2212 return t.(IRelease_stmtContext) 2213 } 2214 2215 func (s *Sql_stmtContext) Rollback_stmt() IRollback_stmtContext { 2216 var t antlr.RuleContext 2217 for _, ctx := range s.GetChildren() { 2218 if _, ok := ctx.(IRollback_stmtContext); ok { 2219 t = ctx.(antlr.RuleContext) 2220 break 2221 } 2222 } 2223 2224 if t == nil { 2225 return nil 2226 } 2227 2228 return t.(IRollback_stmtContext) 2229 } 2230 2231 func (s *Sql_stmtContext) Savepoint_stmt() ISavepoint_stmtContext { 2232 var t antlr.RuleContext 2233 for _, ctx := range s.GetChildren() { 2234 if _, ok := ctx.(ISavepoint_stmtContext); ok { 2235 t = ctx.(antlr.RuleContext) 2236 break 2237 } 2238 } 2239 2240 if t == nil { 2241 return nil 2242 } 2243 2244 return t.(ISavepoint_stmtContext) 2245 } 2246 2247 func (s *Sql_stmtContext) Select_stmt() ISelect_stmtContext { 2248 var t antlr.RuleContext 2249 for _, ctx := range s.GetChildren() { 2250 if _, ok := ctx.(ISelect_stmtContext); ok { 2251 t = ctx.(antlr.RuleContext) 2252 break 2253 } 2254 } 2255 2256 if t == nil { 2257 return nil 2258 } 2259 2260 return t.(ISelect_stmtContext) 2261 } 2262 2263 func (s *Sql_stmtContext) Update_stmt() IUpdate_stmtContext { 2264 var t antlr.RuleContext 2265 for _, ctx := range s.GetChildren() { 2266 if _, ok := ctx.(IUpdate_stmtContext); ok { 2267 t = ctx.(antlr.RuleContext) 2268 break 2269 } 2270 } 2271 2272 if t == nil { 2273 return nil 2274 } 2275 2276 return t.(IUpdate_stmtContext) 2277 } 2278 2279 func (s *Sql_stmtContext) Update_stmt_limited() IUpdate_stmt_limitedContext { 2280 var t antlr.RuleContext 2281 for _, ctx := range s.GetChildren() { 2282 if _, ok := ctx.(IUpdate_stmt_limitedContext); ok { 2283 t = ctx.(antlr.RuleContext) 2284 break 2285 } 2286 } 2287 2288 if t == nil { 2289 return nil 2290 } 2291 2292 return t.(IUpdate_stmt_limitedContext) 2293 } 2294 2295 func (s *Sql_stmtContext) Vacuum_stmt() IVacuum_stmtContext { 2296 var t antlr.RuleContext 2297 for _, ctx := range s.GetChildren() { 2298 if _, ok := ctx.(IVacuum_stmtContext); ok { 2299 t = ctx.(antlr.RuleContext) 2300 break 2301 } 2302 } 2303 2304 if t == nil { 2305 return nil 2306 } 2307 2308 return t.(IVacuum_stmtContext) 2309 } 2310 2311 func (s *Sql_stmtContext) EXPLAIN_() antlr.TerminalNode { 2312 return s.GetToken(ParserEXPLAIN_, 0) 2313 } 2314 2315 func (s *Sql_stmtContext) QUERY_() antlr.TerminalNode { 2316 return s.GetToken(ParserQUERY_, 0) 2317 } 2318 2319 func (s *Sql_stmtContext) PLAN_() antlr.TerminalNode { 2320 return s.GetToken(ParserPLAN_, 0) 2321 } 2322 2323 func (s *Sql_stmtContext) GetRuleContext() antlr.RuleContext { 2324 return s 2325 } 2326 2327 func (s *Sql_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 2328 return antlr.TreesStringTree(s, ruleNames, recog) 2329 } 2330 2331 func (s *Sql_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 2332 if listenerT, ok := listener.(ParserListener); ok { 2333 listenerT.EnterSql_stmt(s) 2334 } 2335 } 2336 2337 func (s *Sql_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 2338 if listenerT, ok := listener.(ParserListener); ok { 2339 listenerT.ExitSql_stmt(s) 2340 } 2341 } 2342 2343 func (s *Sql_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 2344 switch t := visitor.(type) { 2345 case ParserVisitor: 2346 return t.VisitSql_stmt(s) 2347 2348 default: 2349 return t.VisitChildren(s) 2350 } 2351 } 2352 2353 func (p *Parser) Sql_stmt() (localctx ISql_stmtContext) { 2354 this := p 2355 _ = this 2356 2357 localctx = NewSql_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 2358 p.EnterRule(localctx, 4, ParserRULE_sql_stmt) 2359 var _la int 2360 2361 defer func() { 2362 p.ExitRule() 2363 }() 2364 2365 defer func() { 2366 if err := recover(); err != nil { 2367 if v, ok := err.(antlr.RecognitionException); ok { 2368 localctx.SetException(v) 2369 p.GetErrorHandler().ReportError(p, v) 2370 p.GetErrorHandler().Recover(p, v) 2371 } else { 2372 panic(err) 2373 } 2374 } 2375 }() 2376 2377 p.EnterOuterAlt(localctx, 1) 2378 p.SetState(263) 2379 p.GetErrorHandler().Sync(p) 2380 _la = p.GetTokenStream().LA(1) 2381 2382 if _la == ParserEXPLAIN_ { 2383 { 2384 p.SetState(258) 2385 p.Match(ParserEXPLAIN_) 2386 } 2387 p.SetState(261) 2388 p.GetErrorHandler().Sync(p) 2389 _la = p.GetTokenStream().LA(1) 2390 2391 if _la == ParserQUERY_ { 2392 { 2393 p.SetState(259) 2394 p.Match(ParserQUERY_) 2395 } 2396 { 2397 p.SetState(260) 2398 p.Match(ParserPLAN_) 2399 } 2400 2401 } 2402 2403 } 2404 p.SetState(289) 2405 p.GetErrorHandler().Sync(p) 2406 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 7, p.GetParserRuleContext()) { 2407 case 1: 2408 { 2409 p.SetState(265) 2410 p.Alter_table_stmt() 2411 } 2412 2413 case 2: 2414 { 2415 p.SetState(266) 2416 p.Analyze_stmt() 2417 } 2418 2419 case 3: 2420 { 2421 p.SetState(267) 2422 p.Attach_stmt() 2423 } 2424 2425 case 4: 2426 { 2427 p.SetState(268) 2428 p.Begin_stmt() 2429 } 2430 2431 case 5: 2432 { 2433 p.SetState(269) 2434 p.Commit_stmt() 2435 } 2436 2437 case 6: 2438 { 2439 p.SetState(270) 2440 p.Create_index_stmt() 2441 } 2442 2443 case 7: 2444 { 2445 p.SetState(271) 2446 p.Create_table_stmt() 2447 } 2448 2449 case 8: 2450 { 2451 p.SetState(272) 2452 p.Create_trigger_stmt() 2453 } 2454 2455 case 9: 2456 { 2457 p.SetState(273) 2458 p.Create_view_stmt() 2459 } 2460 2461 case 10: 2462 { 2463 p.SetState(274) 2464 p.Create_virtual_table_stmt() 2465 } 2466 2467 case 11: 2468 { 2469 p.SetState(275) 2470 p.Delete_stmt() 2471 } 2472 2473 case 12: 2474 { 2475 p.SetState(276) 2476 p.Delete_stmt_limited() 2477 } 2478 2479 case 13: 2480 { 2481 p.SetState(277) 2482 p.Detach_stmt() 2483 } 2484 2485 case 14: 2486 { 2487 p.SetState(278) 2488 p.Drop_stmt() 2489 } 2490 2491 case 15: 2492 { 2493 p.SetState(279) 2494 p.Insert_stmt() 2495 } 2496 2497 case 16: 2498 { 2499 p.SetState(280) 2500 p.Pragma_stmt() 2501 } 2502 2503 case 17: 2504 { 2505 p.SetState(281) 2506 p.Reindex_stmt() 2507 } 2508 2509 case 18: 2510 { 2511 p.SetState(282) 2512 p.Release_stmt() 2513 } 2514 2515 case 19: 2516 { 2517 p.SetState(283) 2518 p.Rollback_stmt() 2519 } 2520 2521 case 20: 2522 { 2523 p.SetState(284) 2524 p.Savepoint_stmt() 2525 } 2526 2527 case 21: 2528 { 2529 p.SetState(285) 2530 p.Select_stmt() 2531 } 2532 2533 case 22: 2534 { 2535 p.SetState(286) 2536 p.Update_stmt() 2537 } 2538 2539 case 23: 2540 { 2541 p.SetState(287) 2542 p.Update_stmt_limited() 2543 } 2544 2545 case 24: 2546 { 2547 p.SetState(288) 2548 p.Vacuum_stmt() 2549 } 2550 2551 } 2552 2553 return localctx 2554 } 2555 2556 // IAlter_table_stmtContext is an interface to support dynamic dispatch. 2557 type IAlter_table_stmtContext interface { 2558 antlr.ParserRuleContext 2559 2560 // GetParser returns the parser. 2561 GetParser() antlr.Parser 2562 2563 // GetNew_table_name returns the new_table_name rule contexts. 2564 GetNew_table_name() ITable_nameContext 2565 2566 // GetOld_column_name returns the old_column_name rule contexts. 2567 GetOld_column_name() IColumn_nameContext 2568 2569 // GetNew_column_name returns the new_column_name rule contexts. 2570 GetNew_column_name() IColumn_nameContext 2571 2572 // SetNew_table_name sets the new_table_name rule contexts. 2573 SetNew_table_name(ITable_nameContext) 2574 2575 // SetOld_column_name sets the old_column_name rule contexts. 2576 SetOld_column_name(IColumn_nameContext) 2577 2578 // SetNew_column_name sets the new_column_name rule contexts. 2579 SetNew_column_name(IColumn_nameContext) 2580 2581 // IsAlter_table_stmtContext differentiates from other interfaces. 2582 IsAlter_table_stmtContext() 2583 } 2584 2585 type Alter_table_stmtContext struct { 2586 *antlr.BaseParserRuleContext 2587 parser antlr.Parser 2588 new_table_name ITable_nameContext 2589 old_column_name IColumn_nameContext 2590 new_column_name IColumn_nameContext 2591 } 2592 2593 func NewEmptyAlter_table_stmtContext() *Alter_table_stmtContext { 2594 var p = new(Alter_table_stmtContext) 2595 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 2596 p.RuleIndex = ParserRULE_alter_table_stmt 2597 return p 2598 } 2599 2600 func (*Alter_table_stmtContext) IsAlter_table_stmtContext() {} 2601 2602 func NewAlter_table_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_table_stmtContext { 2603 var p = new(Alter_table_stmtContext) 2604 2605 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 2606 2607 p.parser = parser 2608 p.RuleIndex = ParserRULE_alter_table_stmt 2609 2610 return p 2611 } 2612 2613 func (s *Alter_table_stmtContext) GetParser() antlr.Parser { return s.parser } 2614 2615 func (s *Alter_table_stmtContext) GetNew_table_name() ITable_nameContext { return s.new_table_name } 2616 2617 func (s *Alter_table_stmtContext) GetOld_column_name() IColumn_nameContext { return s.old_column_name } 2618 2619 func (s *Alter_table_stmtContext) GetNew_column_name() IColumn_nameContext { return s.new_column_name } 2620 2621 func (s *Alter_table_stmtContext) SetNew_table_name(v ITable_nameContext) { s.new_table_name = v } 2622 2623 func (s *Alter_table_stmtContext) SetOld_column_name(v IColumn_nameContext) { s.old_column_name = v } 2624 2625 func (s *Alter_table_stmtContext) SetNew_column_name(v IColumn_nameContext) { s.new_column_name = v } 2626 2627 func (s *Alter_table_stmtContext) ALTER_() antlr.TerminalNode { 2628 return s.GetToken(ParserALTER_, 0) 2629 } 2630 2631 func (s *Alter_table_stmtContext) TABLE_() antlr.TerminalNode { 2632 return s.GetToken(ParserTABLE_, 0) 2633 } 2634 2635 func (s *Alter_table_stmtContext) AllTable_name() []ITable_nameContext { 2636 children := s.GetChildren() 2637 len := 0 2638 for _, ctx := range children { 2639 if _, ok := ctx.(ITable_nameContext); ok { 2640 len++ 2641 } 2642 } 2643 2644 tst := make([]ITable_nameContext, len) 2645 i := 0 2646 for _, ctx := range children { 2647 if t, ok := ctx.(ITable_nameContext); ok { 2648 tst[i] = t.(ITable_nameContext) 2649 i++ 2650 } 2651 } 2652 2653 return tst 2654 } 2655 2656 func (s *Alter_table_stmtContext) Table_name(i int) ITable_nameContext { 2657 var t antlr.RuleContext 2658 j := 0 2659 for _, ctx := range s.GetChildren() { 2660 if _, ok := ctx.(ITable_nameContext); ok { 2661 if j == i { 2662 t = ctx.(antlr.RuleContext) 2663 break 2664 } 2665 j++ 2666 } 2667 } 2668 2669 if t == nil { 2670 return nil 2671 } 2672 2673 return t.(ITable_nameContext) 2674 } 2675 2676 func (s *Alter_table_stmtContext) RENAME_() antlr.TerminalNode { 2677 return s.GetToken(ParserRENAME_, 0) 2678 } 2679 2680 func (s *Alter_table_stmtContext) ADD_() antlr.TerminalNode { 2681 return s.GetToken(ParserADD_, 0) 2682 } 2683 2684 func (s *Alter_table_stmtContext) Column_def() IColumn_defContext { 2685 var t antlr.RuleContext 2686 for _, ctx := range s.GetChildren() { 2687 if _, ok := ctx.(IColumn_defContext); ok { 2688 t = ctx.(antlr.RuleContext) 2689 break 2690 } 2691 } 2692 2693 if t == nil { 2694 return nil 2695 } 2696 2697 return t.(IColumn_defContext) 2698 } 2699 2700 func (s *Alter_table_stmtContext) DROP_() antlr.TerminalNode { 2701 return s.GetToken(ParserDROP_, 0) 2702 } 2703 2704 func (s *Alter_table_stmtContext) AllColumn_name() []IColumn_nameContext { 2705 children := s.GetChildren() 2706 len := 0 2707 for _, ctx := range children { 2708 if _, ok := ctx.(IColumn_nameContext); ok { 2709 len++ 2710 } 2711 } 2712 2713 tst := make([]IColumn_nameContext, len) 2714 i := 0 2715 for _, ctx := range children { 2716 if t, ok := ctx.(IColumn_nameContext); ok { 2717 tst[i] = t.(IColumn_nameContext) 2718 i++ 2719 } 2720 } 2721 2722 return tst 2723 } 2724 2725 func (s *Alter_table_stmtContext) Column_name(i int) IColumn_nameContext { 2726 var t antlr.RuleContext 2727 j := 0 2728 for _, ctx := range s.GetChildren() { 2729 if _, ok := ctx.(IColumn_nameContext); ok { 2730 if j == i { 2731 t = ctx.(antlr.RuleContext) 2732 break 2733 } 2734 j++ 2735 } 2736 } 2737 2738 if t == nil { 2739 return nil 2740 } 2741 2742 return t.(IColumn_nameContext) 2743 } 2744 2745 func (s *Alter_table_stmtContext) Schema_name() ISchema_nameContext { 2746 var t antlr.RuleContext 2747 for _, ctx := range s.GetChildren() { 2748 if _, ok := ctx.(ISchema_nameContext); ok { 2749 t = ctx.(antlr.RuleContext) 2750 break 2751 } 2752 } 2753 2754 if t == nil { 2755 return nil 2756 } 2757 2758 return t.(ISchema_nameContext) 2759 } 2760 2761 func (s *Alter_table_stmtContext) DOT() antlr.TerminalNode { 2762 return s.GetToken(ParserDOT, 0) 2763 } 2764 2765 func (s *Alter_table_stmtContext) TO_() antlr.TerminalNode { 2766 return s.GetToken(ParserTO_, 0) 2767 } 2768 2769 func (s *Alter_table_stmtContext) COLUMN_() antlr.TerminalNode { 2770 return s.GetToken(ParserCOLUMN_, 0) 2771 } 2772 2773 func (s *Alter_table_stmtContext) GetRuleContext() antlr.RuleContext { 2774 return s 2775 } 2776 2777 func (s *Alter_table_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 2778 return antlr.TreesStringTree(s, ruleNames, recog) 2779 } 2780 2781 func (s *Alter_table_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 2782 if listenerT, ok := listener.(ParserListener); ok { 2783 listenerT.EnterAlter_table_stmt(s) 2784 } 2785 } 2786 2787 func (s *Alter_table_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 2788 if listenerT, ok := listener.(ParserListener); ok { 2789 listenerT.ExitAlter_table_stmt(s) 2790 } 2791 } 2792 2793 func (s *Alter_table_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 2794 switch t := visitor.(type) { 2795 case ParserVisitor: 2796 return t.VisitAlter_table_stmt(s) 2797 2798 default: 2799 return t.VisitChildren(s) 2800 } 2801 } 2802 2803 func (p *Parser) Alter_table_stmt() (localctx IAlter_table_stmtContext) { 2804 this := p 2805 _ = this 2806 2807 localctx = NewAlter_table_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 2808 p.EnterRule(localctx, 6, ParserRULE_alter_table_stmt) 2809 2810 defer func() { 2811 p.ExitRule() 2812 }() 2813 2814 defer func() { 2815 if err := recover(); err != nil { 2816 if v, ok := err.(antlr.RecognitionException); ok { 2817 localctx.SetException(v) 2818 p.GetErrorHandler().ReportError(p, v) 2819 p.GetErrorHandler().Recover(p, v) 2820 } else { 2821 panic(err) 2822 } 2823 } 2824 }() 2825 2826 p.EnterOuterAlt(localctx, 1) 2827 { 2828 p.SetState(291) 2829 p.Match(ParserALTER_) 2830 } 2831 { 2832 p.SetState(292) 2833 p.Match(ParserTABLE_) 2834 } 2835 p.SetState(296) 2836 p.GetErrorHandler().Sync(p) 2837 2838 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 8, p.GetParserRuleContext()) == 1 { 2839 { 2840 p.SetState(293) 2841 p.Schema_name() 2842 } 2843 { 2844 p.SetState(294) 2845 p.Match(ParserDOT) 2846 } 2847 2848 } 2849 { 2850 p.SetState(298) 2851 p.Table_name() 2852 } 2853 p.SetState(321) 2854 p.GetErrorHandler().Sync(p) 2855 2856 switch p.GetTokenStream().LA(1) { 2857 case ParserRENAME_: 2858 { 2859 p.SetState(299) 2860 p.Match(ParserRENAME_) 2861 } 2862 p.SetState(309) 2863 p.GetErrorHandler().Sync(p) 2864 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 10, p.GetParserRuleContext()) { 2865 case 1: 2866 { 2867 p.SetState(300) 2868 p.Match(ParserTO_) 2869 } 2870 { 2871 p.SetState(301) 2872 2873 var _x = p.Table_name() 2874 2875 localctx.(*Alter_table_stmtContext).new_table_name = _x 2876 } 2877 2878 case 2: 2879 p.SetState(303) 2880 p.GetErrorHandler().Sync(p) 2881 2882 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 9, p.GetParserRuleContext()) == 1 { 2883 { 2884 p.SetState(302) 2885 p.Match(ParserCOLUMN_) 2886 } 2887 2888 } 2889 { 2890 p.SetState(305) 2891 2892 var _x = p.Column_name() 2893 2894 localctx.(*Alter_table_stmtContext).old_column_name = _x 2895 } 2896 { 2897 p.SetState(306) 2898 p.Match(ParserTO_) 2899 } 2900 { 2901 p.SetState(307) 2902 2903 var _x = p.Column_name() 2904 2905 localctx.(*Alter_table_stmtContext).new_column_name = _x 2906 } 2907 2908 } 2909 2910 case ParserADD_: 2911 { 2912 p.SetState(311) 2913 p.Match(ParserADD_) 2914 } 2915 p.SetState(313) 2916 p.GetErrorHandler().Sync(p) 2917 2918 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 11, p.GetParserRuleContext()) == 1 { 2919 { 2920 p.SetState(312) 2921 p.Match(ParserCOLUMN_) 2922 } 2923 2924 } 2925 { 2926 p.SetState(315) 2927 p.Column_def() 2928 } 2929 2930 case ParserDROP_: 2931 { 2932 p.SetState(316) 2933 p.Match(ParserDROP_) 2934 } 2935 p.SetState(318) 2936 p.GetErrorHandler().Sync(p) 2937 2938 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 12, p.GetParserRuleContext()) == 1 { 2939 { 2940 p.SetState(317) 2941 p.Match(ParserCOLUMN_) 2942 } 2943 2944 } 2945 { 2946 p.SetState(320) 2947 p.Column_name() 2948 } 2949 2950 default: 2951 panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) 2952 } 2953 2954 return localctx 2955 } 2956 2957 // IAnalyze_stmtContext is an interface to support dynamic dispatch. 2958 type IAnalyze_stmtContext interface { 2959 antlr.ParserRuleContext 2960 2961 // GetParser returns the parser. 2962 GetParser() antlr.Parser 2963 2964 // IsAnalyze_stmtContext differentiates from other interfaces. 2965 IsAnalyze_stmtContext() 2966 } 2967 2968 type Analyze_stmtContext struct { 2969 *antlr.BaseParserRuleContext 2970 parser antlr.Parser 2971 } 2972 2973 func NewEmptyAnalyze_stmtContext() *Analyze_stmtContext { 2974 var p = new(Analyze_stmtContext) 2975 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 2976 p.RuleIndex = ParserRULE_analyze_stmt 2977 return p 2978 } 2979 2980 func (*Analyze_stmtContext) IsAnalyze_stmtContext() {} 2981 2982 func NewAnalyze_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Analyze_stmtContext { 2983 var p = new(Analyze_stmtContext) 2984 2985 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 2986 2987 p.parser = parser 2988 p.RuleIndex = ParserRULE_analyze_stmt 2989 2990 return p 2991 } 2992 2993 func (s *Analyze_stmtContext) GetParser() antlr.Parser { return s.parser } 2994 2995 func (s *Analyze_stmtContext) ANALYZE_() antlr.TerminalNode { 2996 return s.GetToken(ParserANALYZE_, 0) 2997 } 2998 2999 func (s *Analyze_stmtContext) Schema_name() ISchema_nameContext { 3000 var t antlr.RuleContext 3001 for _, ctx := range s.GetChildren() { 3002 if _, ok := ctx.(ISchema_nameContext); ok { 3003 t = ctx.(antlr.RuleContext) 3004 break 3005 } 3006 } 3007 3008 if t == nil { 3009 return nil 3010 } 3011 3012 return t.(ISchema_nameContext) 3013 } 3014 3015 func (s *Analyze_stmtContext) Table_or_index_name() ITable_or_index_nameContext { 3016 var t antlr.RuleContext 3017 for _, ctx := range s.GetChildren() { 3018 if _, ok := ctx.(ITable_or_index_nameContext); ok { 3019 t = ctx.(antlr.RuleContext) 3020 break 3021 } 3022 } 3023 3024 if t == nil { 3025 return nil 3026 } 3027 3028 return t.(ITable_or_index_nameContext) 3029 } 3030 3031 func (s *Analyze_stmtContext) DOT() antlr.TerminalNode { 3032 return s.GetToken(ParserDOT, 0) 3033 } 3034 3035 func (s *Analyze_stmtContext) GetRuleContext() antlr.RuleContext { 3036 return s 3037 } 3038 3039 func (s *Analyze_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 3040 return antlr.TreesStringTree(s, ruleNames, recog) 3041 } 3042 3043 func (s *Analyze_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 3044 if listenerT, ok := listener.(ParserListener); ok { 3045 listenerT.EnterAnalyze_stmt(s) 3046 } 3047 } 3048 3049 func (s *Analyze_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 3050 if listenerT, ok := listener.(ParserListener); ok { 3051 listenerT.ExitAnalyze_stmt(s) 3052 } 3053 } 3054 3055 func (s *Analyze_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 3056 switch t := visitor.(type) { 3057 case ParserVisitor: 3058 return t.VisitAnalyze_stmt(s) 3059 3060 default: 3061 return t.VisitChildren(s) 3062 } 3063 } 3064 3065 func (p *Parser) Analyze_stmt() (localctx IAnalyze_stmtContext) { 3066 this := p 3067 _ = this 3068 3069 localctx = NewAnalyze_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 3070 p.EnterRule(localctx, 8, ParserRULE_analyze_stmt) 3071 3072 defer func() { 3073 p.ExitRule() 3074 }() 3075 3076 defer func() { 3077 if err := recover(); err != nil { 3078 if v, ok := err.(antlr.RecognitionException); ok { 3079 localctx.SetException(v) 3080 p.GetErrorHandler().ReportError(p, v) 3081 p.GetErrorHandler().Recover(p, v) 3082 } else { 3083 panic(err) 3084 } 3085 } 3086 }() 3087 3088 p.EnterOuterAlt(localctx, 1) 3089 { 3090 p.SetState(323) 3091 p.Match(ParserANALYZE_) 3092 } 3093 p.SetState(331) 3094 p.GetErrorHandler().Sync(p) 3095 3096 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 15, p.GetParserRuleContext()) == 1 { 3097 { 3098 p.SetState(324) 3099 p.Schema_name() 3100 } 3101 3102 } else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 15, p.GetParserRuleContext()) == 2 { 3103 p.SetState(328) 3104 p.GetErrorHandler().Sync(p) 3105 3106 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 14, p.GetParserRuleContext()) == 1 { 3107 { 3108 p.SetState(325) 3109 p.Schema_name() 3110 } 3111 { 3112 p.SetState(326) 3113 p.Match(ParserDOT) 3114 } 3115 3116 } 3117 { 3118 p.SetState(330) 3119 p.Table_or_index_name() 3120 } 3121 3122 } 3123 3124 return localctx 3125 } 3126 3127 // IAttach_stmtContext is an interface to support dynamic dispatch. 3128 type IAttach_stmtContext interface { 3129 antlr.ParserRuleContext 3130 3131 // GetParser returns the parser. 3132 GetParser() antlr.Parser 3133 3134 // IsAttach_stmtContext differentiates from other interfaces. 3135 IsAttach_stmtContext() 3136 } 3137 3138 type Attach_stmtContext struct { 3139 *antlr.BaseParserRuleContext 3140 parser antlr.Parser 3141 } 3142 3143 func NewEmptyAttach_stmtContext() *Attach_stmtContext { 3144 var p = new(Attach_stmtContext) 3145 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 3146 p.RuleIndex = ParserRULE_attach_stmt 3147 return p 3148 } 3149 3150 func (*Attach_stmtContext) IsAttach_stmtContext() {} 3151 3152 func NewAttach_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Attach_stmtContext { 3153 var p = new(Attach_stmtContext) 3154 3155 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 3156 3157 p.parser = parser 3158 p.RuleIndex = ParserRULE_attach_stmt 3159 3160 return p 3161 } 3162 3163 func (s *Attach_stmtContext) GetParser() antlr.Parser { return s.parser } 3164 3165 func (s *Attach_stmtContext) ATTACH_() antlr.TerminalNode { 3166 return s.GetToken(ParserATTACH_, 0) 3167 } 3168 3169 func (s *Attach_stmtContext) Expr() IExprContext { 3170 var t antlr.RuleContext 3171 for _, ctx := range s.GetChildren() { 3172 if _, ok := ctx.(IExprContext); ok { 3173 t = ctx.(antlr.RuleContext) 3174 break 3175 } 3176 } 3177 3178 if t == nil { 3179 return nil 3180 } 3181 3182 return t.(IExprContext) 3183 } 3184 3185 func (s *Attach_stmtContext) AS_() antlr.TerminalNode { 3186 return s.GetToken(ParserAS_, 0) 3187 } 3188 3189 func (s *Attach_stmtContext) Schema_name() ISchema_nameContext { 3190 var t antlr.RuleContext 3191 for _, ctx := range s.GetChildren() { 3192 if _, ok := ctx.(ISchema_nameContext); ok { 3193 t = ctx.(antlr.RuleContext) 3194 break 3195 } 3196 } 3197 3198 if t == nil { 3199 return nil 3200 } 3201 3202 return t.(ISchema_nameContext) 3203 } 3204 3205 func (s *Attach_stmtContext) DATABASE_() antlr.TerminalNode { 3206 return s.GetToken(ParserDATABASE_, 0) 3207 } 3208 3209 func (s *Attach_stmtContext) GetRuleContext() antlr.RuleContext { 3210 return s 3211 } 3212 3213 func (s *Attach_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 3214 return antlr.TreesStringTree(s, ruleNames, recog) 3215 } 3216 3217 func (s *Attach_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 3218 if listenerT, ok := listener.(ParserListener); ok { 3219 listenerT.EnterAttach_stmt(s) 3220 } 3221 } 3222 3223 func (s *Attach_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 3224 if listenerT, ok := listener.(ParserListener); ok { 3225 listenerT.ExitAttach_stmt(s) 3226 } 3227 } 3228 3229 func (s *Attach_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 3230 switch t := visitor.(type) { 3231 case ParserVisitor: 3232 return t.VisitAttach_stmt(s) 3233 3234 default: 3235 return t.VisitChildren(s) 3236 } 3237 } 3238 3239 func (p *Parser) Attach_stmt() (localctx IAttach_stmtContext) { 3240 this := p 3241 _ = this 3242 3243 localctx = NewAttach_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 3244 p.EnterRule(localctx, 10, ParserRULE_attach_stmt) 3245 3246 defer func() { 3247 p.ExitRule() 3248 }() 3249 3250 defer func() { 3251 if err := recover(); err != nil { 3252 if v, ok := err.(antlr.RecognitionException); ok { 3253 localctx.SetException(v) 3254 p.GetErrorHandler().ReportError(p, v) 3255 p.GetErrorHandler().Recover(p, v) 3256 } else { 3257 panic(err) 3258 } 3259 } 3260 }() 3261 3262 p.EnterOuterAlt(localctx, 1) 3263 { 3264 p.SetState(333) 3265 p.Match(ParserATTACH_) 3266 } 3267 p.SetState(335) 3268 p.GetErrorHandler().Sync(p) 3269 3270 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 16, p.GetParserRuleContext()) == 1 { 3271 { 3272 p.SetState(334) 3273 p.Match(ParserDATABASE_) 3274 } 3275 3276 } 3277 { 3278 p.SetState(337) 3279 p.expr(0) 3280 } 3281 { 3282 p.SetState(338) 3283 p.Match(ParserAS_) 3284 } 3285 { 3286 p.SetState(339) 3287 p.Schema_name() 3288 } 3289 3290 return localctx 3291 } 3292 3293 // IBegin_stmtContext is an interface to support dynamic dispatch. 3294 type IBegin_stmtContext interface { 3295 antlr.ParserRuleContext 3296 3297 // GetParser returns the parser. 3298 GetParser() antlr.Parser 3299 3300 // IsBegin_stmtContext differentiates from other interfaces. 3301 IsBegin_stmtContext() 3302 } 3303 3304 type Begin_stmtContext struct { 3305 *antlr.BaseParserRuleContext 3306 parser antlr.Parser 3307 } 3308 3309 func NewEmptyBegin_stmtContext() *Begin_stmtContext { 3310 var p = new(Begin_stmtContext) 3311 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 3312 p.RuleIndex = ParserRULE_begin_stmt 3313 return p 3314 } 3315 3316 func (*Begin_stmtContext) IsBegin_stmtContext() {} 3317 3318 func NewBegin_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Begin_stmtContext { 3319 var p = new(Begin_stmtContext) 3320 3321 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 3322 3323 p.parser = parser 3324 p.RuleIndex = ParserRULE_begin_stmt 3325 3326 return p 3327 } 3328 3329 func (s *Begin_stmtContext) GetParser() antlr.Parser { return s.parser } 3330 3331 func (s *Begin_stmtContext) BEGIN_() antlr.TerminalNode { 3332 return s.GetToken(ParserBEGIN_, 0) 3333 } 3334 3335 func (s *Begin_stmtContext) TRANSACTION_() antlr.TerminalNode { 3336 return s.GetToken(ParserTRANSACTION_, 0) 3337 } 3338 3339 func (s *Begin_stmtContext) DEFERRED_() antlr.TerminalNode { 3340 return s.GetToken(ParserDEFERRED_, 0) 3341 } 3342 3343 func (s *Begin_stmtContext) IMMEDIATE_() antlr.TerminalNode { 3344 return s.GetToken(ParserIMMEDIATE_, 0) 3345 } 3346 3347 func (s *Begin_stmtContext) EXCLUSIVE_() antlr.TerminalNode { 3348 return s.GetToken(ParserEXCLUSIVE_, 0) 3349 } 3350 3351 func (s *Begin_stmtContext) Transaction_name() ITransaction_nameContext { 3352 var t antlr.RuleContext 3353 for _, ctx := range s.GetChildren() { 3354 if _, ok := ctx.(ITransaction_nameContext); ok { 3355 t = ctx.(antlr.RuleContext) 3356 break 3357 } 3358 } 3359 3360 if t == nil { 3361 return nil 3362 } 3363 3364 return t.(ITransaction_nameContext) 3365 } 3366 3367 func (s *Begin_stmtContext) GetRuleContext() antlr.RuleContext { 3368 return s 3369 } 3370 3371 func (s *Begin_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 3372 return antlr.TreesStringTree(s, ruleNames, recog) 3373 } 3374 3375 func (s *Begin_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 3376 if listenerT, ok := listener.(ParserListener); ok { 3377 listenerT.EnterBegin_stmt(s) 3378 } 3379 } 3380 3381 func (s *Begin_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 3382 if listenerT, ok := listener.(ParserListener); ok { 3383 listenerT.ExitBegin_stmt(s) 3384 } 3385 } 3386 3387 func (s *Begin_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 3388 switch t := visitor.(type) { 3389 case ParserVisitor: 3390 return t.VisitBegin_stmt(s) 3391 3392 default: 3393 return t.VisitChildren(s) 3394 } 3395 } 3396 3397 func (p *Parser) Begin_stmt() (localctx IBegin_stmtContext) { 3398 this := p 3399 _ = this 3400 3401 localctx = NewBegin_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 3402 p.EnterRule(localctx, 12, ParserRULE_begin_stmt) 3403 var _la int 3404 3405 defer func() { 3406 p.ExitRule() 3407 }() 3408 3409 defer func() { 3410 if err := recover(); err != nil { 3411 if v, ok := err.(antlr.RecognitionException); ok { 3412 localctx.SetException(v) 3413 p.GetErrorHandler().ReportError(p, v) 3414 p.GetErrorHandler().Recover(p, v) 3415 } else { 3416 panic(err) 3417 } 3418 } 3419 }() 3420 3421 p.EnterOuterAlt(localctx, 1) 3422 { 3423 p.SetState(341) 3424 p.Match(ParserBEGIN_) 3425 } 3426 p.SetState(343) 3427 p.GetErrorHandler().Sync(p) 3428 _la = p.GetTokenStream().LA(1) 3429 3430 if ((_la-58)&-(0x1f+1)) == 0 && ((1<<uint((_la-58)))&((1<<(ParserDEFERRED_-58))|(1<<(ParserEXCLUSIVE_-58))|(1<<(ParserIMMEDIATE_-58)))) != 0 { 3431 { 3432 p.SetState(342) 3433 _la = p.GetTokenStream().LA(1) 3434 3435 if !(((_la-58)&-(0x1f+1)) == 0 && ((1<<uint((_la-58)))&((1<<(ParserDEFERRED_-58))|(1<<(ParserEXCLUSIVE_-58))|(1<<(ParserIMMEDIATE_-58)))) != 0) { 3436 p.GetErrorHandler().RecoverInline(p) 3437 } else { 3438 p.GetErrorHandler().ReportMatch(p) 3439 p.Consume() 3440 } 3441 } 3442 3443 } 3444 p.SetState(349) 3445 p.GetErrorHandler().Sync(p) 3446 _la = p.GetTokenStream().LA(1) 3447 3448 if _la == ParserTRANSACTION_ { 3449 { 3450 p.SetState(345) 3451 p.Match(ParserTRANSACTION_) 3452 } 3453 p.SetState(347) 3454 p.GetErrorHandler().Sync(p) 3455 3456 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 18, p.GetParserRuleContext()) == 1 { 3457 { 3458 p.SetState(346) 3459 p.Transaction_name() 3460 } 3461 3462 } 3463 3464 } 3465 3466 return localctx 3467 } 3468 3469 // ICommit_stmtContext is an interface to support dynamic dispatch. 3470 type ICommit_stmtContext interface { 3471 antlr.ParserRuleContext 3472 3473 // GetParser returns the parser. 3474 GetParser() antlr.Parser 3475 3476 // IsCommit_stmtContext differentiates from other interfaces. 3477 IsCommit_stmtContext() 3478 } 3479 3480 type Commit_stmtContext struct { 3481 *antlr.BaseParserRuleContext 3482 parser antlr.Parser 3483 } 3484 3485 func NewEmptyCommit_stmtContext() *Commit_stmtContext { 3486 var p = new(Commit_stmtContext) 3487 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 3488 p.RuleIndex = ParserRULE_commit_stmt 3489 return p 3490 } 3491 3492 func (*Commit_stmtContext) IsCommit_stmtContext() {} 3493 3494 func NewCommit_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Commit_stmtContext { 3495 var p = new(Commit_stmtContext) 3496 3497 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 3498 3499 p.parser = parser 3500 p.RuleIndex = ParserRULE_commit_stmt 3501 3502 return p 3503 } 3504 3505 func (s *Commit_stmtContext) GetParser() antlr.Parser { return s.parser } 3506 3507 func (s *Commit_stmtContext) COMMIT_() antlr.TerminalNode { 3508 return s.GetToken(ParserCOMMIT_, 0) 3509 } 3510 3511 func (s *Commit_stmtContext) END_() antlr.TerminalNode { 3512 return s.GetToken(ParserEND_, 0) 3513 } 3514 3515 func (s *Commit_stmtContext) TRANSACTION_() antlr.TerminalNode { 3516 return s.GetToken(ParserTRANSACTION_, 0) 3517 } 3518 3519 func (s *Commit_stmtContext) GetRuleContext() antlr.RuleContext { 3520 return s 3521 } 3522 3523 func (s *Commit_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 3524 return antlr.TreesStringTree(s, ruleNames, recog) 3525 } 3526 3527 func (s *Commit_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 3528 if listenerT, ok := listener.(ParserListener); ok { 3529 listenerT.EnterCommit_stmt(s) 3530 } 3531 } 3532 3533 func (s *Commit_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 3534 if listenerT, ok := listener.(ParserListener); ok { 3535 listenerT.ExitCommit_stmt(s) 3536 } 3537 } 3538 3539 func (s *Commit_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 3540 switch t := visitor.(type) { 3541 case ParserVisitor: 3542 return t.VisitCommit_stmt(s) 3543 3544 default: 3545 return t.VisitChildren(s) 3546 } 3547 } 3548 3549 func (p *Parser) Commit_stmt() (localctx ICommit_stmtContext) { 3550 this := p 3551 _ = this 3552 3553 localctx = NewCommit_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 3554 p.EnterRule(localctx, 14, ParserRULE_commit_stmt) 3555 var _la int 3556 3557 defer func() { 3558 p.ExitRule() 3559 }() 3560 3561 defer func() { 3562 if err := recover(); err != nil { 3563 if v, ok := err.(antlr.RecognitionException); ok { 3564 localctx.SetException(v) 3565 p.GetErrorHandler().ReportError(p, v) 3566 p.GetErrorHandler().Recover(p, v) 3567 } else { 3568 panic(err) 3569 } 3570 } 3571 }() 3572 3573 p.EnterOuterAlt(localctx, 1) 3574 { 3575 p.SetState(351) 3576 _la = p.GetTokenStream().LA(1) 3577 3578 if !(_la == ParserCOMMIT_ || _la == ParserEND_) { 3579 p.GetErrorHandler().RecoverInline(p) 3580 } else { 3581 p.GetErrorHandler().ReportMatch(p) 3582 p.Consume() 3583 } 3584 } 3585 p.SetState(353) 3586 p.GetErrorHandler().Sync(p) 3587 _la = p.GetTokenStream().LA(1) 3588 3589 if _la == ParserTRANSACTION_ { 3590 { 3591 p.SetState(352) 3592 p.Match(ParserTRANSACTION_) 3593 } 3594 3595 } 3596 3597 return localctx 3598 } 3599 3600 // IRollback_stmtContext is an interface to support dynamic dispatch. 3601 type IRollback_stmtContext interface { 3602 antlr.ParserRuleContext 3603 3604 // GetParser returns the parser. 3605 GetParser() antlr.Parser 3606 3607 // IsRollback_stmtContext differentiates from other interfaces. 3608 IsRollback_stmtContext() 3609 } 3610 3611 type Rollback_stmtContext struct { 3612 *antlr.BaseParserRuleContext 3613 parser antlr.Parser 3614 } 3615 3616 func NewEmptyRollback_stmtContext() *Rollback_stmtContext { 3617 var p = new(Rollback_stmtContext) 3618 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 3619 p.RuleIndex = ParserRULE_rollback_stmt 3620 return p 3621 } 3622 3623 func (*Rollback_stmtContext) IsRollback_stmtContext() {} 3624 3625 func NewRollback_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rollback_stmtContext { 3626 var p = new(Rollback_stmtContext) 3627 3628 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 3629 3630 p.parser = parser 3631 p.RuleIndex = ParserRULE_rollback_stmt 3632 3633 return p 3634 } 3635 3636 func (s *Rollback_stmtContext) GetParser() antlr.Parser { return s.parser } 3637 3638 func (s *Rollback_stmtContext) ROLLBACK_() antlr.TerminalNode { 3639 return s.GetToken(ParserROLLBACK_, 0) 3640 } 3641 3642 func (s *Rollback_stmtContext) TRANSACTION_() antlr.TerminalNode { 3643 return s.GetToken(ParserTRANSACTION_, 0) 3644 } 3645 3646 func (s *Rollback_stmtContext) TO_() antlr.TerminalNode { 3647 return s.GetToken(ParserTO_, 0) 3648 } 3649 3650 func (s *Rollback_stmtContext) Savepoint_name() ISavepoint_nameContext { 3651 var t antlr.RuleContext 3652 for _, ctx := range s.GetChildren() { 3653 if _, ok := ctx.(ISavepoint_nameContext); ok { 3654 t = ctx.(antlr.RuleContext) 3655 break 3656 } 3657 } 3658 3659 if t == nil { 3660 return nil 3661 } 3662 3663 return t.(ISavepoint_nameContext) 3664 } 3665 3666 func (s *Rollback_stmtContext) SAVEPOINT_() antlr.TerminalNode { 3667 return s.GetToken(ParserSAVEPOINT_, 0) 3668 } 3669 3670 func (s *Rollback_stmtContext) GetRuleContext() antlr.RuleContext { 3671 return s 3672 } 3673 3674 func (s *Rollback_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 3675 return antlr.TreesStringTree(s, ruleNames, recog) 3676 } 3677 3678 func (s *Rollback_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 3679 if listenerT, ok := listener.(ParserListener); ok { 3680 listenerT.EnterRollback_stmt(s) 3681 } 3682 } 3683 3684 func (s *Rollback_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 3685 if listenerT, ok := listener.(ParserListener); ok { 3686 listenerT.ExitRollback_stmt(s) 3687 } 3688 } 3689 3690 func (s *Rollback_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 3691 switch t := visitor.(type) { 3692 case ParserVisitor: 3693 return t.VisitRollback_stmt(s) 3694 3695 default: 3696 return t.VisitChildren(s) 3697 } 3698 } 3699 3700 func (p *Parser) Rollback_stmt() (localctx IRollback_stmtContext) { 3701 this := p 3702 _ = this 3703 3704 localctx = NewRollback_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 3705 p.EnterRule(localctx, 16, ParserRULE_rollback_stmt) 3706 var _la int 3707 3708 defer func() { 3709 p.ExitRule() 3710 }() 3711 3712 defer func() { 3713 if err := recover(); err != nil { 3714 if v, ok := err.(antlr.RecognitionException); ok { 3715 localctx.SetException(v) 3716 p.GetErrorHandler().ReportError(p, v) 3717 p.GetErrorHandler().Recover(p, v) 3718 } else { 3719 panic(err) 3720 } 3721 } 3722 }() 3723 3724 p.EnterOuterAlt(localctx, 1) 3725 { 3726 p.SetState(355) 3727 p.Match(ParserROLLBACK_) 3728 } 3729 p.SetState(357) 3730 p.GetErrorHandler().Sync(p) 3731 _la = p.GetTokenStream().LA(1) 3732 3733 if _la == ParserTRANSACTION_ { 3734 { 3735 p.SetState(356) 3736 p.Match(ParserTRANSACTION_) 3737 } 3738 3739 } 3740 p.SetState(364) 3741 p.GetErrorHandler().Sync(p) 3742 _la = p.GetTokenStream().LA(1) 3743 3744 if _la == ParserTO_ { 3745 { 3746 p.SetState(359) 3747 p.Match(ParserTO_) 3748 } 3749 p.SetState(361) 3750 p.GetErrorHandler().Sync(p) 3751 3752 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 22, p.GetParserRuleContext()) == 1 { 3753 { 3754 p.SetState(360) 3755 p.Match(ParserSAVEPOINT_) 3756 } 3757 3758 } 3759 { 3760 p.SetState(363) 3761 p.Savepoint_name() 3762 } 3763 3764 } 3765 3766 return localctx 3767 } 3768 3769 // ISavepoint_stmtContext is an interface to support dynamic dispatch. 3770 type ISavepoint_stmtContext interface { 3771 antlr.ParserRuleContext 3772 3773 // GetParser returns the parser. 3774 GetParser() antlr.Parser 3775 3776 // IsSavepoint_stmtContext differentiates from other interfaces. 3777 IsSavepoint_stmtContext() 3778 } 3779 3780 type Savepoint_stmtContext struct { 3781 *antlr.BaseParserRuleContext 3782 parser antlr.Parser 3783 } 3784 3785 func NewEmptySavepoint_stmtContext() *Savepoint_stmtContext { 3786 var p = new(Savepoint_stmtContext) 3787 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 3788 p.RuleIndex = ParserRULE_savepoint_stmt 3789 return p 3790 } 3791 3792 func (*Savepoint_stmtContext) IsSavepoint_stmtContext() {} 3793 3794 func NewSavepoint_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Savepoint_stmtContext { 3795 var p = new(Savepoint_stmtContext) 3796 3797 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 3798 3799 p.parser = parser 3800 p.RuleIndex = ParserRULE_savepoint_stmt 3801 3802 return p 3803 } 3804 3805 func (s *Savepoint_stmtContext) GetParser() antlr.Parser { return s.parser } 3806 3807 func (s *Savepoint_stmtContext) SAVEPOINT_() antlr.TerminalNode { 3808 return s.GetToken(ParserSAVEPOINT_, 0) 3809 } 3810 3811 func (s *Savepoint_stmtContext) Savepoint_name() ISavepoint_nameContext { 3812 var t antlr.RuleContext 3813 for _, ctx := range s.GetChildren() { 3814 if _, ok := ctx.(ISavepoint_nameContext); ok { 3815 t = ctx.(antlr.RuleContext) 3816 break 3817 } 3818 } 3819 3820 if t == nil { 3821 return nil 3822 } 3823 3824 return t.(ISavepoint_nameContext) 3825 } 3826 3827 func (s *Savepoint_stmtContext) GetRuleContext() antlr.RuleContext { 3828 return s 3829 } 3830 3831 func (s *Savepoint_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 3832 return antlr.TreesStringTree(s, ruleNames, recog) 3833 } 3834 3835 func (s *Savepoint_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 3836 if listenerT, ok := listener.(ParserListener); ok { 3837 listenerT.EnterSavepoint_stmt(s) 3838 } 3839 } 3840 3841 func (s *Savepoint_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 3842 if listenerT, ok := listener.(ParserListener); ok { 3843 listenerT.ExitSavepoint_stmt(s) 3844 } 3845 } 3846 3847 func (s *Savepoint_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 3848 switch t := visitor.(type) { 3849 case ParserVisitor: 3850 return t.VisitSavepoint_stmt(s) 3851 3852 default: 3853 return t.VisitChildren(s) 3854 } 3855 } 3856 3857 func (p *Parser) Savepoint_stmt() (localctx ISavepoint_stmtContext) { 3858 this := p 3859 _ = this 3860 3861 localctx = NewSavepoint_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 3862 p.EnterRule(localctx, 18, ParserRULE_savepoint_stmt) 3863 3864 defer func() { 3865 p.ExitRule() 3866 }() 3867 3868 defer func() { 3869 if err := recover(); err != nil { 3870 if v, ok := err.(antlr.RecognitionException); ok { 3871 localctx.SetException(v) 3872 p.GetErrorHandler().ReportError(p, v) 3873 p.GetErrorHandler().Recover(p, v) 3874 } else { 3875 panic(err) 3876 } 3877 } 3878 }() 3879 3880 p.EnterOuterAlt(localctx, 1) 3881 { 3882 p.SetState(366) 3883 p.Match(ParserSAVEPOINT_) 3884 } 3885 { 3886 p.SetState(367) 3887 p.Savepoint_name() 3888 } 3889 3890 return localctx 3891 } 3892 3893 // IRelease_stmtContext is an interface to support dynamic dispatch. 3894 type IRelease_stmtContext interface { 3895 antlr.ParserRuleContext 3896 3897 // GetParser returns the parser. 3898 GetParser() antlr.Parser 3899 3900 // IsRelease_stmtContext differentiates from other interfaces. 3901 IsRelease_stmtContext() 3902 } 3903 3904 type Release_stmtContext struct { 3905 *antlr.BaseParserRuleContext 3906 parser antlr.Parser 3907 } 3908 3909 func NewEmptyRelease_stmtContext() *Release_stmtContext { 3910 var p = new(Release_stmtContext) 3911 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 3912 p.RuleIndex = ParserRULE_release_stmt 3913 return p 3914 } 3915 3916 func (*Release_stmtContext) IsRelease_stmtContext() {} 3917 3918 func NewRelease_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Release_stmtContext { 3919 var p = new(Release_stmtContext) 3920 3921 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 3922 3923 p.parser = parser 3924 p.RuleIndex = ParserRULE_release_stmt 3925 3926 return p 3927 } 3928 3929 func (s *Release_stmtContext) GetParser() antlr.Parser { return s.parser } 3930 3931 func (s *Release_stmtContext) RELEASE_() antlr.TerminalNode { 3932 return s.GetToken(ParserRELEASE_, 0) 3933 } 3934 3935 func (s *Release_stmtContext) Savepoint_name() ISavepoint_nameContext { 3936 var t antlr.RuleContext 3937 for _, ctx := range s.GetChildren() { 3938 if _, ok := ctx.(ISavepoint_nameContext); ok { 3939 t = ctx.(antlr.RuleContext) 3940 break 3941 } 3942 } 3943 3944 if t == nil { 3945 return nil 3946 } 3947 3948 return t.(ISavepoint_nameContext) 3949 } 3950 3951 func (s *Release_stmtContext) SAVEPOINT_() antlr.TerminalNode { 3952 return s.GetToken(ParserSAVEPOINT_, 0) 3953 } 3954 3955 func (s *Release_stmtContext) GetRuleContext() antlr.RuleContext { 3956 return s 3957 } 3958 3959 func (s *Release_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 3960 return antlr.TreesStringTree(s, ruleNames, recog) 3961 } 3962 3963 func (s *Release_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 3964 if listenerT, ok := listener.(ParserListener); ok { 3965 listenerT.EnterRelease_stmt(s) 3966 } 3967 } 3968 3969 func (s *Release_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 3970 if listenerT, ok := listener.(ParserListener); ok { 3971 listenerT.ExitRelease_stmt(s) 3972 } 3973 } 3974 3975 func (s *Release_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 3976 switch t := visitor.(type) { 3977 case ParserVisitor: 3978 return t.VisitRelease_stmt(s) 3979 3980 default: 3981 return t.VisitChildren(s) 3982 } 3983 } 3984 3985 func (p *Parser) Release_stmt() (localctx IRelease_stmtContext) { 3986 this := p 3987 _ = this 3988 3989 localctx = NewRelease_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 3990 p.EnterRule(localctx, 20, ParserRULE_release_stmt) 3991 3992 defer func() { 3993 p.ExitRule() 3994 }() 3995 3996 defer func() { 3997 if err := recover(); err != nil { 3998 if v, ok := err.(antlr.RecognitionException); ok { 3999 localctx.SetException(v) 4000 p.GetErrorHandler().ReportError(p, v) 4001 p.GetErrorHandler().Recover(p, v) 4002 } else { 4003 panic(err) 4004 } 4005 } 4006 }() 4007 4008 p.EnterOuterAlt(localctx, 1) 4009 { 4010 p.SetState(369) 4011 p.Match(ParserRELEASE_) 4012 } 4013 p.SetState(371) 4014 p.GetErrorHandler().Sync(p) 4015 4016 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 24, p.GetParserRuleContext()) == 1 { 4017 { 4018 p.SetState(370) 4019 p.Match(ParserSAVEPOINT_) 4020 } 4021 4022 } 4023 { 4024 p.SetState(373) 4025 p.Savepoint_name() 4026 } 4027 4028 return localctx 4029 } 4030 4031 // ICreate_index_stmtContext is an interface to support dynamic dispatch. 4032 type ICreate_index_stmtContext interface { 4033 antlr.ParserRuleContext 4034 4035 // GetParser returns the parser. 4036 GetParser() antlr.Parser 4037 4038 // IsCreate_index_stmtContext differentiates from other interfaces. 4039 IsCreate_index_stmtContext() 4040 } 4041 4042 type Create_index_stmtContext struct { 4043 *antlr.BaseParserRuleContext 4044 parser antlr.Parser 4045 } 4046 4047 func NewEmptyCreate_index_stmtContext() *Create_index_stmtContext { 4048 var p = new(Create_index_stmtContext) 4049 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 4050 p.RuleIndex = ParserRULE_create_index_stmt 4051 return p 4052 } 4053 4054 func (*Create_index_stmtContext) IsCreate_index_stmtContext() {} 4055 4056 func NewCreate_index_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_index_stmtContext { 4057 var p = new(Create_index_stmtContext) 4058 4059 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 4060 4061 p.parser = parser 4062 p.RuleIndex = ParserRULE_create_index_stmt 4063 4064 return p 4065 } 4066 4067 func (s *Create_index_stmtContext) GetParser() antlr.Parser { return s.parser } 4068 4069 func (s *Create_index_stmtContext) CREATE_() antlr.TerminalNode { 4070 return s.GetToken(ParserCREATE_, 0) 4071 } 4072 4073 func (s *Create_index_stmtContext) INDEX_() antlr.TerminalNode { 4074 return s.GetToken(ParserINDEX_, 0) 4075 } 4076 4077 func (s *Create_index_stmtContext) Index_name() IIndex_nameContext { 4078 var t antlr.RuleContext 4079 for _, ctx := range s.GetChildren() { 4080 if _, ok := ctx.(IIndex_nameContext); ok { 4081 t = ctx.(antlr.RuleContext) 4082 break 4083 } 4084 } 4085 4086 if t == nil { 4087 return nil 4088 } 4089 4090 return t.(IIndex_nameContext) 4091 } 4092 4093 func (s *Create_index_stmtContext) ON_() antlr.TerminalNode { 4094 return s.GetToken(ParserON_, 0) 4095 } 4096 4097 func (s *Create_index_stmtContext) Table_name() ITable_nameContext { 4098 var t antlr.RuleContext 4099 for _, ctx := range s.GetChildren() { 4100 if _, ok := ctx.(ITable_nameContext); ok { 4101 t = ctx.(antlr.RuleContext) 4102 break 4103 } 4104 } 4105 4106 if t == nil { 4107 return nil 4108 } 4109 4110 return t.(ITable_nameContext) 4111 } 4112 4113 func (s *Create_index_stmtContext) OPEN_PAR() antlr.TerminalNode { 4114 return s.GetToken(ParserOPEN_PAR, 0) 4115 } 4116 4117 func (s *Create_index_stmtContext) AllIndexed_column() []IIndexed_columnContext { 4118 children := s.GetChildren() 4119 len := 0 4120 for _, ctx := range children { 4121 if _, ok := ctx.(IIndexed_columnContext); ok { 4122 len++ 4123 } 4124 } 4125 4126 tst := make([]IIndexed_columnContext, len) 4127 i := 0 4128 for _, ctx := range children { 4129 if t, ok := ctx.(IIndexed_columnContext); ok { 4130 tst[i] = t.(IIndexed_columnContext) 4131 i++ 4132 } 4133 } 4134 4135 return tst 4136 } 4137 4138 func (s *Create_index_stmtContext) Indexed_column(i int) IIndexed_columnContext { 4139 var t antlr.RuleContext 4140 j := 0 4141 for _, ctx := range s.GetChildren() { 4142 if _, ok := ctx.(IIndexed_columnContext); ok { 4143 if j == i { 4144 t = ctx.(antlr.RuleContext) 4145 break 4146 } 4147 j++ 4148 } 4149 } 4150 4151 if t == nil { 4152 return nil 4153 } 4154 4155 return t.(IIndexed_columnContext) 4156 } 4157 4158 func (s *Create_index_stmtContext) CLOSE_PAR() antlr.TerminalNode { 4159 return s.GetToken(ParserCLOSE_PAR, 0) 4160 } 4161 4162 func (s *Create_index_stmtContext) UNIQUE_() antlr.TerminalNode { 4163 return s.GetToken(ParserUNIQUE_, 0) 4164 } 4165 4166 func (s *Create_index_stmtContext) IF_() antlr.TerminalNode { 4167 return s.GetToken(ParserIF_, 0) 4168 } 4169 4170 func (s *Create_index_stmtContext) NOT_() antlr.TerminalNode { 4171 return s.GetToken(ParserNOT_, 0) 4172 } 4173 4174 func (s *Create_index_stmtContext) EXISTS_() antlr.TerminalNode { 4175 return s.GetToken(ParserEXISTS_, 0) 4176 } 4177 4178 func (s *Create_index_stmtContext) Schema_name() ISchema_nameContext { 4179 var t antlr.RuleContext 4180 for _, ctx := range s.GetChildren() { 4181 if _, ok := ctx.(ISchema_nameContext); ok { 4182 t = ctx.(antlr.RuleContext) 4183 break 4184 } 4185 } 4186 4187 if t == nil { 4188 return nil 4189 } 4190 4191 return t.(ISchema_nameContext) 4192 } 4193 4194 func (s *Create_index_stmtContext) DOT() antlr.TerminalNode { 4195 return s.GetToken(ParserDOT, 0) 4196 } 4197 4198 func (s *Create_index_stmtContext) AllCOMMA() []antlr.TerminalNode { 4199 return s.GetTokens(ParserCOMMA) 4200 } 4201 4202 func (s *Create_index_stmtContext) COMMA(i int) antlr.TerminalNode { 4203 return s.GetToken(ParserCOMMA, i) 4204 } 4205 4206 func (s *Create_index_stmtContext) WHERE_() antlr.TerminalNode { 4207 return s.GetToken(ParserWHERE_, 0) 4208 } 4209 4210 func (s *Create_index_stmtContext) Expr() IExprContext { 4211 var t antlr.RuleContext 4212 for _, ctx := range s.GetChildren() { 4213 if _, ok := ctx.(IExprContext); ok { 4214 t = ctx.(antlr.RuleContext) 4215 break 4216 } 4217 } 4218 4219 if t == nil { 4220 return nil 4221 } 4222 4223 return t.(IExprContext) 4224 } 4225 4226 func (s *Create_index_stmtContext) GetRuleContext() antlr.RuleContext { 4227 return s 4228 } 4229 4230 func (s *Create_index_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 4231 return antlr.TreesStringTree(s, ruleNames, recog) 4232 } 4233 4234 func (s *Create_index_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 4235 if listenerT, ok := listener.(ParserListener); ok { 4236 listenerT.EnterCreate_index_stmt(s) 4237 } 4238 } 4239 4240 func (s *Create_index_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 4241 if listenerT, ok := listener.(ParserListener); ok { 4242 listenerT.ExitCreate_index_stmt(s) 4243 } 4244 } 4245 4246 func (s *Create_index_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 4247 switch t := visitor.(type) { 4248 case ParserVisitor: 4249 return t.VisitCreate_index_stmt(s) 4250 4251 default: 4252 return t.VisitChildren(s) 4253 } 4254 } 4255 4256 func (p *Parser) Create_index_stmt() (localctx ICreate_index_stmtContext) { 4257 this := p 4258 _ = this 4259 4260 localctx = NewCreate_index_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 4261 p.EnterRule(localctx, 22, ParserRULE_create_index_stmt) 4262 var _la int 4263 4264 defer func() { 4265 p.ExitRule() 4266 }() 4267 4268 defer func() { 4269 if err := recover(); err != nil { 4270 if v, ok := err.(antlr.RecognitionException); ok { 4271 localctx.SetException(v) 4272 p.GetErrorHandler().ReportError(p, v) 4273 p.GetErrorHandler().Recover(p, v) 4274 } else { 4275 panic(err) 4276 } 4277 } 4278 }() 4279 4280 p.EnterOuterAlt(localctx, 1) 4281 { 4282 p.SetState(375) 4283 p.Match(ParserCREATE_) 4284 } 4285 p.SetState(377) 4286 p.GetErrorHandler().Sync(p) 4287 _la = p.GetTokenStream().LA(1) 4288 4289 if _la == ParserUNIQUE_ { 4290 { 4291 p.SetState(376) 4292 p.Match(ParserUNIQUE_) 4293 } 4294 4295 } 4296 { 4297 p.SetState(379) 4298 p.Match(ParserINDEX_) 4299 } 4300 p.SetState(383) 4301 p.GetErrorHandler().Sync(p) 4302 4303 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 26, p.GetParserRuleContext()) == 1 { 4304 { 4305 p.SetState(380) 4306 p.Match(ParserIF_) 4307 } 4308 { 4309 p.SetState(381) 4310 p.Match(ParserNOT_) 4311 } 4312 { 4313 p.SetState(382) 4314 p.Match(ParserEXISTS_) 4315 } 4316 4317 } 4318 p.SetState(388) 4319 p.GetErrorHandler().Sync(p) 4320 4321 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 27, p.GetParserRuleContext()) == 1 { 4322 { 4323 p.SetState(385) 4324 p.Schema_name() 4325 } 4326 { 4327 p.SetState(386) 4328 p.Match(ParserDOT) 4329 } 4330 4331 } 4332 { 4333 p.SetState(390) 4334 p.Index_name() 4335 } 4336 { 4337 p.SetState(391) 4338 p.Match(ParserON_) 4339 } 4340 { 4341 p.SetState(392) 4342 p.Table_name() 4343 } 4344 { 4345 p.SetState(393) 4346 p.Match(ParserOPEN_PAR) 4347 } 4348 { 4349 p.SetState(394) 4350 p.Indexed_column() 4351 } 4352 p.SetState(399) 4353 p.GetErrorHandler().Sync(p) 4354 _la = p.GetTokenStream().LA(1) 4355 4356 for _la == ParserCOMMA { 4357 { 4358 p.SetState(395) 4359 p.Match(ParserCOMMA) 4360 } 4361 { 4362 p.SetState(396) 4363 p.Indexed_column() 4364 } 4365 4366 p.SetState(401) 4367 p.GetErrorHandler().Sync(p) 4368 _la = p.GetTokenStream().LA(1) 4369 } 4370 { 4371 p.SetState(402) 4372 p.Match(ParserCLOSE_PAR) 4373 } 4374 p.SetState(405) 4375 p.GetErrorHandler().Sync(p) 4376 _la = p.GetTokenStream().LA(1) 4377 4378 if _la == ParserWHERE_ { 4379 { 4380 p.SetState(403) 4381 p.Match(ParserWHERE_) 4382 } 4383 { 4384 p.SetState(404) 4385 p.expr(0) 4386 } 4387 4388 } 4389 4390 return localctx 4391 } 4392 4393 // IIndexed_columnContext is an interface to support dynamic dispatch. 4394 type IIndexed_columnContext interface { 4395 antlr.ParserRuleContext 4396 4397 // GetParser returns the parser. 4398 GetParser() antlr.Parser 4399 4400 // IsIndexed_columnContext differentiates from other interfaces. 4401 IsIndexed_columnContext() 4402 } 4403 4404 type Indexed_columnContext struct { 4405 *antlr.BaseParserRuleContext 4406 parser antlr.Parser 4407 } 4408 4409 func NewEmptyIndexed_columnContext() *Indexed_columnContext { 4410 var p = new(Indexed_columnContext) 4411 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 4412 p.RuleIndex = ParserRULE_indexed_column 4413 return p 4414 } 4415 4416 func (*Indexed_columnContext) IsIndexed_columnContext() {} 4417 4418 func NewIndexed_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Indexed_columnContext { 4419 var p = new(Indexed_columnContext) 4420 4421 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 4422 4423 p.parser = parser 4424 p.RuleIndex = ParserRULE_indexed_column 4425 4426 return p 4427 } 4428 4429 func (s *Indexed_columnContext) GetParser() antlr.Parser { return s.parser } 4430 4431 func (s *Indexed_columnContext) Column_name() IColumn_nameContext { 4432 var t antlr.RuleContext 4433 for _, ctx := range s.GetChildren() { 4434 if _, ok := ctx.(IColumn_nameContext); ok { 4435 t = ctx.(antlr.RuleContext) 4436 break 4437 } 4438 } 4439 4440 if t == nil { 4441 return nil 4442 } 4443 4444 return t.(IColumn_nameContext) 4445 } 4446 4447 func (s *Indexed_columnContext) Expr() IExprContext { 4448 var t antlr.RuleContext 4449 for _, ctx := range s.GetChildren() { 4450 if _, ok := ctx.(IExprContext); ok { 4451 t = ctx.(antlr.RuleContext) 4452 break 4453 } 4454 } 4455 4456 if t == nil { 4457 return nil 4458 } 4459 4460 return t.(IExprContext) 4461 } 4462 4463 func (s *Indexed_columnContext) COLLATE_() antlr.TerminalNode { 4464 return s.GetToken(ParserCOLLATE_, 0) 4465 } 4466 4467 func (s *Indexed_columnContext) Collation_name() ICollation_nameContext { 4468 var t antlr.RuleContext 4469 for _, ctx := range s.GetChildren() { 4470 if _, ok := ctx.(ICollation_nameContext); ok { 4471 t = ctx.(antlr.RuleContext) 4472 break 4473 } 4474 } 4475 4476 if t == nil { 4477 return nil 4478 } 4479 4480 return t.(ICollation_nameContext) 4481 } 4482 4483 func (s *Indexed_columnContext) Asc_desc() IAsc_descContext { 4484 var t antlr.RuleContext 4485 for _, ctx := range s.GetChildren() { 4486 if _, ok := ctx.(IAsc_descContext); ok { 4487 t = ctx.(antlr.RuleContext) 4488 break 4489 } 4490 } 4491 4492 if t == nil { 4493 return nil 4494 } 4495 4496 return t.(IAsc_descContext) 4497 } 4498 4499 func (s *Indexed_columnContext) GetRuleContext() antlr.RuleContext { 4500 return s 4501 } 4502 4503 func (s *Indexed_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 4504 return antlr.TreesStringTree(s, ruleNames, recog) 4505 } 4506 4507 func (s *Indexed_columnContext) EnterRule(listener antlr.ParseTreeListener) { 4508 if listenerT, ok := listener.(ParserListener); ok { 4509 listenerT.EnterIndexed_column(s) 4510 } 4511 } 4512 4513 func (s *Indexed_columnContext) ExitRule(listener antlr.ParseTreeListener) { 4514 if listenerT, ok := listener.(ParserListener); ok { 4515 listenerT.ExitIndexed_column(s) 4516 } 4517 } 4518 4519 func (s *Indexed_columnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 4520 switch t := visitor.(type) { 4521 case ParserVisitor: 4522 return t.VisitIndexed_column(s) 4523 4524 default: 4525 return t.VisitChildren(s) 4526 } 4527 } 4528 4529 func (p *Parser) Indexed_column() (localctx IIndexed_columnContext) { 4530 this := p 4531 _ = this 4532 4533 localctx = NewIndexed_columnContext(p, p.GetParserRuleContext(), p.GetState()) 4534 p.EnterRule(localctx, 24, ParserRULE_indexed_column) 4535 var _la int 4536 4537 defer func() { 4538 p.ExitRule() 4539 }() 4540 4541 defer func() { 4542 if err := recover(); err != nil { 4543 if v, ok := err.(antlr.RecognitionException); ok { 4544 localctx.SetException(v) 4545 p.GetErrorHandler().ReportError(p, v) 4546 p.GetErrorHandler().Recover(p, v) 4547 } else { 4548 panic(err) 4549 } 4550 } 4551 }() 4552 4553 p.EnterOuterAlt(localctx, 1) 4554 p.SetState(409) 4555 p.GetErrorHandler().Sync(p) 4556 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 30, p.GetParserRuleContext()) { 4557 case 1: 4558 { 4559 p.SetState(407) 4560 p.Column_name() 4561 } 4562 4563 case 2: 4564 { 4565 p.SetState(408) 4566 p.expr(0) 4567 } 4568 4569 } 4570 p.SetState(413) 4571 p.GetErrorHandler().Sync(p) 4572 _la = p.GetTokenStream().LA(1) 4573 4574 if _la == ParserCOLLATE_ { 4575 { 4576 p.SetState(411) 4577 p.Match(ParserCOLLATE_) 4578 } 4579 { 4580 p.SetState(412) 4581 p.Collation_name() 4582 } 4583 4584 } 4585 p.SetState(416) 4586 p.GetErrorHandler().Sync(p) 4587 _la = p.GetTokenStream().LA(1) 4588 4589 if _la == ParserASC_ || _la == ParserDESC_ { 4590 { 4591 p.SetState(415) 4592 p.Asc_desc() 4593 } 4594 4595 } 4596 4597 return localctx 4598 } 4599 4600 // ICreate_table_stmtContext is an interface to support dynamic dispatch. 4601 type ICreate_table_stmtContext interface { 4602 antlr.ParserRuleContext 4603 4604 // GetParser returns the parser. 4605 GetParser() antlr.Parser 4606 4607 // GetRow_ROW_ID returns the row_ROW_ID token. 4608 GetRow_ROW_ID() antlr.Token 4609 4610 // SetRow_ROW_ID sets the row_ROW_ID token. 4611 SetRow_ROW_ID(antlr.Token) 4612 4613 // IsCreate_table_stmtContext differentiates from other interfaces. 4614 IsCreate_table_stmtContext() 4615 } 4616 4617 type Create_table_stmtContext struct { 4618 *antlr.BaseParserRuleContext 4619 parser antlr.Parser 4620 row_ROW_ID antlr.Token 4621 } 4622 4623 func NewEmptyCreate_table_stmtContext() *Create_table_stmtContext { 4624 var p = new(Create_table_stmtContext) 4625 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 4626 p.RuleIndex = ParserRULE_create_table_stmt 4627 return p 4628 } 4629 4630 func (*Create_table_stmtContext) IsCreate_table_stmtContext() {} 4631 4632 func NewCreate_table_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_table_stmtContext { 4633 var p = new(Create_table_stmtContext) 4634 4635 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 4636 4637 p.parser = parser 4638 p.RuleIndex = ParserRULE_create_table_stmt 4639 4640 return p 4641 } 4642 4643 func (s *Create_table_stmtContext) GetParser() antlr.Parser { return s.parser } 4644 4645 func (s *Create_table_stmtContext) GetRow_ROW_ID() antlr.Token { return s.row_ROW_ID } 4646 4647 func (s *Create_table_stmtContext) SetRow_ROW_ID(v antlr.Token) { s.row_ROW_ID = v } 4648 4649 func (s *Create_table_stmtContext) CREATE_() antlr.TerminalNode { 4650 return s.GetToken(ParserCREATE_, 0) 4651 } 4652 4653 func (s *Create_table_stmtContext) TABLE_() antlr.TerminalNode { 4654 return s.GetToken(ParserTABLE_, 0) 4655 } 4656 4657 func (s *Create_table_stmtContext) Table_name() ITable_nameContext { 4658 var t antlr.RuleContext 4659 for _, ctx := range s.GetChildren() { 4660 if _, ok := ctx.(ITable_nameContext); ok { 4661 t = ctx.(antlr.RuleContext) 4662 break 4663 } 4664 } 4665 4666 if t == nil { 4667 return nil 4668 } 4669 4670 return t.(ITable_nameContext) 4671 } 4672 4673 func (s *Create_table_stmtContext) OPEN_PAR() antlr.TerminalNode { 4674 return s.GetToken(ParserOPEN_PAR, 0) 4675 } 4676 4677 func (s *Create_table_stmtContext) AllColumn_def() []IColumn_defContext { 4678 children := s.GetChildren() 4679 len := 0 4680 for _, ctx := range children { 4681 if _, ok := ctx.(IColumn_defContext); ok { 4682 len++ 4683 } 4684 } 4685 4686 tst := make([]IColumn_defContext, len) 4687 i := 0 4688 for _, ctx := range children { 4689 if t, ok := ctx.(IColumn_defContext); ok { 4690 tst[i] = t.(IColumn_defContext) 4691 i++ 4692 } 4693 } 4694 4695 return tst 4696 } 4697 4698 func (s *Create_table_stmtContext) Column_def(i int) IColumn_defContext { 4699 var t antlr.RuleContext 4700 j := 0 4701 for _, ctx := range s.GetChildren() { 4702 if _, ok := ctx.(IColumn_defContext); ok { 4703 if j == i { 4704 t = ctx.(antlr.RuleContext) 4705 break 4706 } 4707 j++ 4708 } 4709 } 4710 4711 if t == nil { 4712 return nil 4713 } 4714 4715 return t.(IColumn_defContext) 4716 } 4717 4718 func (s *Create_table_stmtContext) CLOSE_PAR() antlr.TerminalNode { 4719 return s.GetToken(ParserCLOSE_PAR, 0) 4720 } 4721 4722 func (s *Create_table_stmtContext) AS_() antlr.TerminalNode { 4723 return s.GetToken(ParserAS_, 0) 4724 } 4725 4726 func (s *Create_table_stmtContext) Select_stmt() ISelect_stmtContext { 4727 var t antlr.RuleContext 4728 for _, ctx := range s.GetChildren() { 4729 if _, ok := ctx.(ISelect_stmtContext); ok { 4730 t = ctx.(antlr.RuleContext) 4731 break 4732 } 4733 } 4734 4735 if t == nil { 4736 return nil 4737 } 4738 4739 return t.(ISelect_stmtContext) 4740 } 4741 4742 func (s *Create_table_stmtContext) IF_() antlr.TerminalNode { 4743 return s.GetToken(ParserIF_, 0) 4744 } 4745 4746 func (s *Create_table_stmtContext) NOT_() antlr.TerminalNode { 4747 return s.GetToken(ParserNOT_, 0) 4748 } 4749 4750 func (s *Create_table_stmtContext) EXISTS_() antlr.TerminalNode { 4751 return s.GetToken(ParserEXISTS_, 0) 4752 } 4753 4754 func (s *Create_table_stmtContext) Schema_name() ISchema_nameContext { 4755 var t antlr.RuleContext 4756 for _, ctx := range s.GetChildren() { 4757 if _, ok := ctx.(ISchema_nameContext); ok { 4758 t = ctx.(antlr.RuleContext) 4759 break 4760 } 4761 } 4762 4763 if t == nil { 4764 return nil 4765 } 4766 4767 return t.(ISchema_nameContext) 4768 } 4769 4770 func (s *Create_table_stmtContext) DOT() antlr.TerminalNode { 4771 return s.GetToken(ParserDOT, 0) 4772 } 4773 4774 func (s *Create_table_stmtContext) TEMP_() antlr.TerminalNode { 4775 return s.GetToken(ParserTEMP_, 0) 4776 } 4777 4778 func (s *Create_table_stmtContext) TEMPORARY_() antlr.TerminalNode { 4779 return s.GetToken(ParserTEMPORARY_, 0) 4780 } 4781 4782 func (s *Create_table_stmtContext) AllCOMMA() []antlr.TerminalNode { 4783 return s.GetTokens(ParserCOMMA) 4784 } 4785 4786 func (s *Create_table_stmtContext) COMMA(i int) antlr.TerminalNode { 4787 return s.GetToken(ParserCOMMA, i) 4788 } 4789 4790 func (s *Create_table_stmtContext) AllTable_constraint() []ITable_constraintContext { 4791 children := s.GetChildren() 4792 len := 0 4793 for _, ctx := range children { 4794 if _, ok := ctx.(ITable_constraintContext); ok { 4795 len++ 4796 } 4797 } 4798 4799 tst := make([]ITable_constraintContext, len) 4800 i := 0 4801 for _, ctx := range children { 4802 if t, ok := ctx.(ITable_constraintContext); ok { 4803 tst[i] = t.(ITable_constraintContext) 4804 i++ 4805 } 4806 } 4807 4808 return tst 4809 } 4810 4811 func (s *Create_table_stmtContext) Table_constraint(i int) ITable_constraintContext { 4812 var t antlr.RuleContext 4813 j := 0 4814 for _, ctx := range s.GetChildren() { 4815 if _, ok := ctx.(ITable_constraintContext); ok { 4816 if j == i { 4817 t = ctx.(antlr.RuleContext) 4818 break 4819 } 4820 j++ 4821 } 4822 } 4823 4824 if t == nil { 4825 return nil 4826 } 4827 4828 return t.(ITable_constraintContext) 4829 } 4830 4831 func (s *Create_table_stmtContext) WITHOUT_() antlr.TerminalNode { 4832 return s.GetToken(ParserWITHOUT_, 0) 4833 } 4834 4835 func (s *Create_table_stmtContext) IDENTIFIER() antlr.TerminalNode { 4836 return s.GetToken(ParserIDENTIFIER, 0) 4837 } 4838 4839 func (s *Create_table_stmtContext) GetRuleContext() antlr.RuleContext { 4840 return s 4841 } 4842 4843 func (s *Create_table_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 4844 return antlr.TreesStringTree(s, ruleNames, recog) 4845 } 4846 4847 func (s *Create_table_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 4848 if listenerT, ok := listener.(ParserListener); ok { 4849 listenerT.EnterCreate_table_stmt(s) 4850 } 4851 } 4852 4853 func (s *Create_table_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 4854 if listenerT, ok := listener.(ParserListener); ok { 4855 listenerT.ExitCreate_table_stmt(s) 4856 } 4857 } 4858 4859 func (s *Create_table_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 4860 switch t := visitor.(type) { 4861 case ParserVisitor: 4862 return t.VisitCreate_table_stmt(s) 4863 4864 default: 4865 return t.VisitChildren(s) 4866 } 4867 } 4868 4869 func (p *Parser) Create_table_stmt() (localctx ICreate_table_stmtContext) { 4870 this := p 4871 _ = this 4872 4873 localctx = NewCreate_table_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 4874 p.EnterRule(localctx, 26, ParserRULE_create_table_stmt) 4875 var _la int 4876 4877 defer func() { 4878 p.ExitRule() 4879 }() 4880 4881 defer func() { 4882 if err := recover(); err != nil { 4883 if v, ok := err.(antlr.RecognitionException); ok { 4884 localctx.SetException(v) 4885 p.GetErrorHandler().ReportError(p, v) 4886 p.GetErrorHandler().Recover(p, v) 4887 } else { 4888 panic(err) 4889 } 4890 } 4891 }() 4892 4893 var _alt int 4894 4895 p.EnterOuterAlt(localctx, 1) 4896 { 4897 p.SetState(418) 4898 p.Match(ParserCREATE_) 4899 } 4900 p.SetState(420) 4901 p.GetErrorHandler().Sync(p) 4902 _la = p.GetTokenStream().LA(1) 4903 4904 if _la == ParserTEMP_ || _la == ParserTEMPORARY_ { 4905 { 4906 p.SetState(419) 4907 _la = p.GetTokenStream().LA(1) 4908 4909 if !(_la == ParserTEMP_ || _la == ParserTEMPORARY_) { 4910 p.GetErrorHandler().RecoverInline(p) 4911 } else { 4912 p.GetErrorHandler().ReportMatch(p) 4913 p.Consume() 4914 } 4915 } 4916 4917 } 4918 { 4919 p.SetState(422) 4920 p.Match(ParserTABLE_) 4921 } 4922 p.SetState(426) 4923 p.GetErrorHandler().Sync(p) 4924 4925 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 34, p.GetParserRuleContext()) == 1 { 4926 { 4927 p.SetState(423) 4928 p.Match(ParserIF_) 4929 } 4930 { 4931 p.SetState(424) 4932 p.Match(ParserNOT_) 4933 } 4934 { 4935 p.SetState(425) 4936 p.Match(ParserEXISTS_) 4937 } 4938 4939 } 4940 p.SetState(431) 4941 p.GetErrorHandler().Sync(p) 4942 4943 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 35, p.GetParserRuleContext()) == 1 { 4944 { 4945 p.SetState(428) 4946 p.Schema_name() 4947 } 4948 { 4949 p.SetState(429) 4950 p.Match(ParserDOT) 4951 } 4952 4953 } 4954 { 4955 p.SetState(433) 4956 p.Table_name() 4957 } 4958 p.SetState(457) 4959 p.GetErrorHandler().Sync(p) 4960 4961 switch p.GetTokenStream().LA(1) { 4962 case ParserOPEN_PAR: 4963 { 4964 p.SetState(434) 4965 p.Match(ParserOPEN_PAR) 4966 } 4967 { 4968 p.SetState(435) 4969 p.Column_def() 4970 } 4971 p.SetState(440) 4972 p.GetErrorHandler().Sync(p) 4973 _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 36, p.GetParserRuleContext()) 4974 4975 for _alt != 1 && _alt != antlr.ATNInvalidAltNumber { 4976 if _alt == 1+1 { 4977 { 4978 p.SetState(436) 4979 p.Match(ParserCOMMA) 4980 } 4981 { 4982 p.SetState(437) 4983 p.Column_def() 4984 } 4985 4986 } 4987 p.SetState(442) 4988 p.GetErrorHandler().Sync(p) 4989 _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 36, p.GetParserRuleContext()) 4990 } 4991 p.SetState(447) 4992 p.GetErrorHandler().Sync(p) 4993 _la = p.GetTokenStream().LA(1) 4994 4995 for _la == ParserCOMMA { 4996 { 4997 p.SetState(443) 4998 p.Match(ParserCOMMA) 4999 } 5000 { 5001 p.SetState(444) 5002 p.Table_constraint() 5003 } 5004 5005 p.SetState(449) 5006 p.GetErrorHandler().Sync(p) 5007 _la = p.GetTokenStream().LA(1) 5008 } 5009 { 5010 p.SetState(450) 5011 p.Match(ParserCLOSE_PAR) 5012 } 5013 p.SetState(453) 5014 p.GetErrorHandler().Sync(p) 5015 _la = p.GetTokenStream().LA(1) 5016 5017 if _la == ParserWITHOUT_ { 5018 { 5019 p.SetState(451) 5020 p.Match(ParserWITHOUT_) 5021 } 5022 { 5023 p.SetState(452) 5024 5025 var _m = p.Match(ParserIDENTIFIER) 5026 5027 localctx.(*Create_table_stmtContext).row_ROW_ID = _m 5028 } 5029 5030 } 5031 5032 case ParserAS_: 5033 { 5034 p.SetState(455) 5035 p.Match(ParserAS_) 5036 } 5037 { 5038 p.SetState(456) 5039 p.Select_stmt() 5040 } 5041 5042 default: 5043 panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) 5044 } 5045 5046 return localctx 5047 } 5048 5049 // IColumn_defContext is an interface to support dynamic dispatch. 5050 type IColumn_defContext interface { 5051 antlr.ParserRuleContext 5052 5053 // GetParser returns the parser. 5054 GetParser() antlr.Parser 5055 5056 // IsColumn_defContext differentiates from other interfaces. 5057 IsColumn_defContext() 5058 } 5059 5060 type Column_defContext struct { 5061 *antlr.BaseParserRuleContext 5062 parser antlr.Parser 5063 } 5064 5065 func NewEmptyColumn_defContext() *Column_defContext { 5066 var p = new(Column_defContext) 5067 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 5068 p.RuleIndex = ParserRULE_column_def 5069 return p 5070 } 5071 5072 func (*Column_defContext) IsColumn_defContext() {} 5073 5074 func NewColumn_defContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_defContext { 5075 var p = new(Column_defContext) 5076 5077 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 5078 5079 p.parser = parser 5080 p.RuleIndex = ParserRULE_column_def 5081 5082 return p 5083 } 5084 5085 func (s *Column_defContext) GetParser() antlr.Parser { return s.parser } 5086 5087 func (s *Column_defContext) Column_name() IColumn_nameContext { 5088 var t antlr.RuleContext 5089 for _, ctx := range s.GetChildren() { 5090 if _, ok := ctx.(IColumn_nameContext); ok { 5091 t = ctx.(antlr.RuleContext) 5092 break 5093 } 5094 } 5095 5096 if t == nil { 5097 return nil 5098 } 5099 5100 return t.(IColumn_nameContext) 5101 } 5102 5103 func (s *Column_defContext) Type_name() IType_nameContext { 5104 var t antlr.RuleContext 5105 for _, ctx := range s.GetChildren() { 5106 if _, ok := ctx.(IType_nameContext); ok { 5107 t = ctx.(antlr.RuleContext) 5108 break 5109 } 5110 } 5111 5112 if t == nil { 5113 return nil 5114 } 5115 5116 return t.(IType_nameContext) 5117 } 5118 5119 func (s *Column_defContext) AllColumn_constraint() []IColumn_constraintContext { 5120 children := s.GetChildren() 5121 len := 0 5122 for _, ctx := range children { 5123 if _, ok := ctx.(IColumn_constraintContext); ok { 5124 len++ 5125 } 5126 } 5127 5128 tst := make([]IColumn_constraintContext, len) 5129 i := 0 5130 for _, ctx := range children { 5131 if t, ok := ctx.(IColumn_constraintContext); ok { 5132 tst[i] = t.(IColumn_constraintContext) 5133 i++ 5134 } 5135 } 5136 5137 return tst 5138 } 5139 5140 func (s *Column_defContext) Column_constraint(i int) IColumn_constraintContext { 5141 var t antlr.RuleContext 5142 j := 0 5143 for _, ctx := range s.GetChildren() { 5144 if _, ok := ctx.(IColumn_constraintContext); ok { 5145 if j == i { 5146 t = ctx.(antlr.RuleContext) 5147 break 5148 } 5149 j++ 5150 } 5151 } 5152 5153 if t == nil { 5154 return nil 5155 } 5156 5157 return t.(IColumn_constraintContext) 5158 } 5159 5160 func (s *Column_defContext) GetRuleContext() antlr.RuleContext { 5161 return s 5162 } 5163 5164 func (s *Column_defContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 5165 return antlr.TreesStringTree(s, ruleNames, recog) 5166 } 5167 5168 func (s *Column_defContext) EnterRule(listener antlr.ParseTreeListener) { 5169 if listenerT, ok := listener.(ParserListener); ok { 5170 listenerT.EnterColumn_def(s) 5171 } 5172 } 5173 5174 func (s *Column_defContext) ExitRule(listener antlr.ParseTreeListener) { 5175 if listenerT, ok := listener.(ParserListener); ok { 5176 listenerT.ExitColumn_def(s) 5177 } 5178 } 5179 5180 func (s *Column_defContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 5181 switch t := visitor.(type) { 5182 case ParserVisitor: 5183 return t.VisitColumn_def(s) 5184 5185 default: 5186 return t.VisitChildren(s) 5187 } 5188 } 5189 5190 func (p *Parser) Column_def() (localctx IColumn_defContext) { 5191 this := p 5192 _ = this 5193 5194 localctx = NewColumn_defContext(p, p.GetParserRuleContext(), p.GetState()) 5195 p.EnterRule(localctx, 28, ParserRULE_column_def) 5196 var _la int 5197 5198 defer func() { 5199 p.ExitRule() 5200 }() 5201 5202 defer func() { 5203 if err := recover(); err != nil { 5204 if v, ok := err.(antlr.RecognitionException); ok { 5205 localctx.SetException(v) 5206 p.GetErrorHandler().ReportError(p, v) 5207 p.GetErrorHandler().Recover(p, v) 5208 } else { 5209 panic(err) 5210 } 5211 } 5212 }() 5213 5214 p.EnterOuterAlt(localctx, 1) 5215 { 5216 p.SetState(459) 5217 p.Column_name() 5218 } 5219 p.SetState(461) 5220 p.GetErrorHandler().Sync(p) 5221 5222 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 40, p.GetParserRuleContext()) == 1 { 5223 { 5224 p.SetState(460) 5225 p.Type_name() 5226 } 5227 5228 } 5229 p.SetState(466) 5230 p.GetErrorHandler().Sync(p) 5231 _la = p.GetTokenStream().LA(1) 5232 5233 for (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(ParserAS_-33))|(1<<(ParserCHECK_-33))|(1<<(ParserCOLLATE_-33))|(1<<(ParserCONSTRAINT_-33))|(1<<(ParserDEFAULT_-33)))) != 0) || (((_la-102)&-(0x1f+1)) == 0 && ((1<<uint((_la-102)))&((1<<(ParserNOT_-102))|(1<<(ParserPRIMARY_-102))|(1<<(ParserREFERENCES_-102)))) != 0) || _la == ParserUNIQUE_ || _la == ParserGENERATED_ { 5234 { 5235 p.SetState(463) 5236 p.Column_constraint() 5237 } 5238 5239 p.SetState(468) 5240 p.GetErrorHandler().Sync(p) 5241 _la = p.GetTokenStream().LA(1) 5242 } 5243 5244 return localctx 5245 } 5246 5247 // IType_nameContext is an interface to support dynamic dispatch. 5248 type IType_nameContext interface { 5249 antlr.ParserRuleContext 5250 5251 // GetParser returns the parser. 5252 GetParser() antlr.Parser 5253 5254 // IsType_nameContext differentiates from other interfaces. 5255 IsType_nameContext() 5256 } 5257 5258 type Type_nameContext struct { 5259 *antlr.BaseParserRuleContext 5260 parser antlr.Parser 5261 } 5262 5263 func NewEmptyType_nameContext() *Type_nameContext { 5264 var p = new(Type_nameContext) 5265 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 5266 p.RuleIndex = ParserRULE_type_name 5267 return p 5268 } 5269 5270 func (*Type_nameContext) IsType_nameContext() {} 5271 5272 func NewType_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_nameContext { 5273 var p = new(Type_nameContext) 5274 5275 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 5276 5277 p.parser = parser 5278 p.RuleIndex = ParserRULE_type_name 5279 5280 return p 5281 } 5282 5283 func (s *Type_nameContext) GetParser() antlr.Parser { return s.parser } 5284 5285 func (s *Type_nameContext) AllName() []INameContext { 5286 children := s.GetChildren() 5287 len := 0 5288 for _, ctx := range children { 5289 if _, ok := ctx.(INameContext); ok { 5290 len++ 5291 } 5292 } 5293 5294 tst := make([]INameContext, len) 5295 i := 0 5296 for _, ctx := range children { 5297 if t, ok := ctx.(INameContext); ok { 5298 tst[i] = t.(INameContext) 5299 i++ 5300 } 5301 } 5302 5303 return tst 5304 } 5305 5306 func (s *Type_nameContext) Name(i int) INameContext { 5307 var t antlr.RuleContext 5308 j := 0 5309 for _, ctx := range s.GetChildren() { 5310 if _, ok := ctx.(INameContext); ok { 5311 if j == i { 5312 t = ctx.(antlr.RuleContext) 5313 break 5314 } 5315 j++ 5316 } 5317 } 5318 5319 if t == nil { 5320 return nil 5321 } 5322 5323 return t.(INameContext) 5324 } 5325 5326 func (s *Type_nameContext) OPEN_PAR() antlr.TerminalNode { 5327 return s.GetToken(ParserOPEN_PAR, 0) 5328 } 5329 5330 func (s *Type_nameContext) AllSigned_number() []ISigned_numberContext { 5331 children := s.GetChildren() 5332 len := 0 5333 for _, ctx := range children { 5334 if _, ok := ctx.(ISigned_numberContext); ok { 5335 len++ 5336 } 5337 } 5338 5339 tst := make([]ISigned_numberContext, len) 5340 i := 0 5341 for _, ctx := range children { 5342 if t, ok := ctx.(ISigned_numberContext); ok { 5343 tst[i] = t.(ISigned_numberContext) 5344 i++ 5345 } 5346 } 5347 5348 return tst 5349 } 5350 5351 func (s *Type_nameContext) Signed_number(i int) ISigned_numberContext { 5352 var t antlr.RuleContext 5353 j := 0 5354 for _, ctx := range s.GetChildren() { 5355 if _, ok := ctx.(ISigned_numberContext); ok { 5356 if j == i { 5357 t = ctx.(antlr.RuleContext) 5358 break 5359 } 5360 j++ 5361 } 5362 } 5363 5364 if t == nil { 5365 return nil 5366 } 5367 5368 return t.(ISigned_numberContext) 5369 } 5370 5371 func (s *Type_nameContext) CLOSE_PAR() antlr.TerminalNode { 5372 return s.GetToken(ParserCLOSE_PAR, 0) 5373 } 5374 5375 func (s *Type_nameContext) COMMA() antlr.TerminalNode { 5376 return s.GetToken(ParserCOMMA, 0) 5377 } 5378 5379 func (s *Type_nameContext) GetRuleContext() antlr.RuleContext { 5380 return s 5381 } 5382 5383 func (s *Type_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 5384 return antlr.TreesStringTree(s, ruleNames, recog) 5385 } 5386 5387 func (s *Type_nameContext) EnterRule(listener antlr.ParseTreeListener) { 5388 if listenerT, ok := listener.(ParserListener); ok { 5389 listenerT.EnterType_name(s) 5390 } 5391 } 5392 5393 func (s *Type_nameContext) ExitRule(listener antlr.ParseTreeListener) { 5394 if listenerT, ok := listener.(ParserListener); ok { 5395 listenerT.ExitType_name(s) 5396 } 5397 } 5398 5399 func (s *Type_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 5400 switch t := visitor.(type) { 5401 case ParserVisitor: 5402 return t.VisitType_name(s) 5403 5404 default: 5405 return t.VisitChildren(s) 5406 } 5407 } 5408 5409 func (p *Parser) Type_name() (localctx IType_nameContext) { 5410 this := p 5411 _ = this 5412 5413 localctx = NewType_nameContext(p, p.GetParserRuleContext(), p.GetState()) 5414 p.EnterRule(localctx, 30, ParserRULE_type_name) 5415 5416 defer func() { 5417 p.ExitRule() 5418 }() 5419 5420 defer func() { 5421 if err := recover(); err != nil { 5422 if v, ok := err.(antlr.RecognitionException); ok { 5423 localctx.SetException(v) 5424 p.GetErrorHandler().ReportError(p, v) 5425 p.GetErrorHandler().Recover(p, v) 5426 } else { 5427 panic(err) 5428 } 5429 } 5430 }() 5431 5432 var _alt int 5433 5434 p.EnterOuterAlt(localctx, 1) 5435 p.SetState(470) 5436 p.GetErrorHandler().Sync(p) 5437 _alt = 1 + 1 5438 for ok := true; ok; ok = _alt != 1 && _alt != antlr.ATNInvalidAltNumber { 5439 switch _alt { 5440 case 1 + 1: 5441 { 5442 p.SetState(469) 5443 p.Name() 5444 } 5445 5446 default: 5447 panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) 5448 } 5449 5450 p.SetState(472) 5451 p.GetErrorHandler().Sync(p) 5452 _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 42, p.GetParserRuleContext()) 5453 } 5454 p.SetState(484) 5455 p.GetErrorHandler().Sync(p) 5456 5457 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 43, p.GetParserRuleContext()) == 1 { 5458 { 5459 p.SetState(474) 5460 p.Match(ParserOPEN_PAR) 5461 } 5462 { 5463 p.SetState(475) 5464 p.Signed_number() 5465 } 5466 { 5467 p.SetState(476) 5468 p.Match(ParserCLOSE_PAR) 5469 } 5470 5471 } else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 43, p.GetParserRuleContext()) == 2 { 5472 { 5473 p.SetState(478) 5474 p.Match(ParserOPEN_PAR) 5475 } 5476 { 5477 p.SetState(479) 5478 p.Signed_number() 5479 } 5480 { 5481 p.SetState(480) 5482 p.Match(ParserCOMMA) 5483 } 5484 { 5485 p.SetState(481) 5486 p.Signed_number() 5487 } 5488 { 5489 p.SetState(482) 5490 p.Match(ParserCLOSE_PAR) 5491 } 5492 5493 } 5494 5495 return localctx 5496 } 5497 5498 // IColumn_constraintContext is an interface to support dynamic dispatch. 5499 type IColumn_constraintContext interface { 5500 antlr.ParserRuleContext 5501 5502 // GetParser returns the parser. 5503 GetParser() antlr.Parser 5504 5505 // IsColumn_constraintContext differentiates from other interfaces. 5506 IsColumn_constraintContext() 5507 } 5508 5509 type Column_constraintContext struct { 5510 *antlr.BaseParserRuleContext 5511 parser antlr.Parser 5512 } 5513 5514 func NewEmptyColumn_constraintContext() *Column_constraintContext { 5515 var p = new(Column_constraintContext) 5516 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 5517 p.RuleIndex = ParserRULE_column_constraint 5518 return p 5519 } 5520 5521 func (*Column_constraintContext) IsColumn_constraintContext() {} 5522 5523 func NewColumn_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_constraintContext { 5524 var p = new(Column_constraintContext) 5525 5526 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 5527 5528 p.parser = parser 5529 p.RuleIndex = ParserRULE_column_constraint 5530 5531 return p 5532 } 5533 5534 func (s *Column_constraintContext) GetParser() antlr.Parser { return s.parser } 5535 5536 func (s *Column_constraintContext) CHECK_() antlr.TerminalNode { 5537 return s.GetToken(ParserCHECK_, 0) 5538 } 5539 5540 func (s *Column_constraintContext) OPEN_PAR() antlr.TerminalNode { 5541 return s.GetToken(ParserOPEN_PAR, 0) 5542 } 5543 5544 func (s *Column_constraintContext) Expr() IExprContext { 5545 var t antlr.RuleContext 5546 for _, ctx := range s.GetChildren() { 5547 if _, ok := ctx.(IExprContext); ok { 5548 t = ctx.(antlr.RuleContext) 5549 break 5550 } 5551 } 5552 5553 if t == nil { 5554 return nil 5555 } 5556 5557 return t.(IExprContext) 5558 } 5559 5560 func (s *Column_constraintContext) CLOSE_PAR() antlr.TerminalNode { 5561 return s.GetToken(ParserCLOSE_PAR, 0) 5562 } 5563 5564 func (s *Column_constraintContext) DEFAULT_() antlr.TerminalNode { 5565 return s.GetToken(ParserDEFAULT_, 0) 5566 } 5567 5568 func (s *Column_constraintContext) COLLATE_() antlr.TerminalNode { 5569 return s.GetToken(ParserCOLLATE_, 0) 5570 } 5571 5572 func (s *Column_constraintContext) Collation_name() ICollation_nameContext { 5573 var t antlr.RuleContext 5574 for _, ctx := range s.GetChildren() { 5575 if _, ok := ctx.(ICollation_nameContext); ok { 5576 t = ctx.(antlr.RuleContext) 5577 break 5578 } 5579 } 5580 5581 if t == nil { 5582 return nil 5583 } 5584 5585 return t.(ICollation_nameContext) 5586 } 5587 5588 func (s *Column_constraintContext) Foreign_key_clause() IForeign_key_clauseContext { 5589 var t antlr.RuleContext 5590 for _, ctx := range s.GetChildren() { 5591 if _, ok := ctx.(IForeign_key_clauseContext); ok { 5592 t = ctx.(antlr.RuleContext) 5593 break 5594 } 5595 } 5596 5597 if t == nil { 5598 return nil 5599 } 5600 5601 return t.(IForeign_key_clauseContext) 5602 } 5603 5604 func (s *Column_constraintContext) AS_() antlr.TerminalNode { 5605 return s.GetToken(ParserAS_, 0) 5606 } 5607 5608 func (s *Column_constraintContext) CONSTRAINT_() antlr.TerminalNode { 5609 return s.GetToken(ParserCONSTRAINT_, 0) 5610 } 5611 5612 func (s *Column_constraintContext) Name() INameContext { 5613 var t antlr.RuleContext 5614 for _, ctx := range s.GetChildren() { 5615 if _, ok := ctx.(INameContext); ok { 5616 t = ctx.(antlr.RuleContext) 5617 break 5618 } 5619 } 5620 5621 if t == nil { 5622 return nil 5623 } 5624 5625 return t.(INameContext) 5626 } 5627 5628 func (s *Column_constraintContext) PRIMARY_() antlr.TerminalNode { 5629 return s.GetToken(ParserPRIMARY_, 0) 5630 } 5631 5632 func (s *Column_constraintContext) KEY_() antlr.TerminalNode { 5633 return s.GetToken(ParserKEY_, 0) 5634 } 5635 5636 func (s *Column_constraintContext) NOT_() antlr.TerminalNode { 5637 return s.GetToken(ParserNOT_, 0) 5638 } 5639 5640 func (s *Column_constraintContext) NULL_() antlr.TerminalNode { 5641 return s.GetToken(ParserNULL_, 0) 5642 } 5643 5644 func (s *Column_constraintContext) UNIQUE_() antlr.TerminalNode { 5645 return s.GetToken(ParserUNIQUE_, 0) 5646 } 5647 5648 func (s *Column_constraintContext) Signed_number() ISigned_numberContext { 5649 var t antlr.RuleContext 5650 for _, ctx := range s.GetChildren() { 5651 if _, ok := ctx.(ISigned_numberContext); ok { 5652 t = ctx.(antlr.RuleContext) 5653 break 5654 } 5655 } 5656 5657 if t == nil { 5658 return nil 5659 } 5660 5661 return t.(ISigned_numberContext) 5662 } 5663 5664 func (s *Column_constraintContext) Literal_value() ILiteral_valueContext { 5665 var t antlr.RuleContext 5666 for _, ctx := range s.GetChildren() { 5667 if _, ok := ctx.(ILiteral_valueContext); ok { 5668 t = ctx.(antlr.RuleContext) 5669 break 5670 } 5671 } 5672 5673 if t == nil { 5674 return nil 5675 } 5676 5677 return t.(ILiteral_valueContext) 5678 } 5679 5680 func (s *Column_constraintContext) Conflict_clause() IConflict_clauseContext { 5681 var t antlr.RuleContext 5682 for _, ctx := range s.GetChildren() { 5683 if _, ok := ctx.(IConflict_clauseContext); ok { 5684 t = ctx.(antlr.RuleContext) 5685 break 5686 } 5687 } 5688 5689 if t == nil { 5690 return nil 5691 } 5692 5693 return t.(IConflict_clauseContext) 5694 } 5695 5696 func (s *Column_constraintContext) GENERATED_() antlr.TerminalNode { 5697 return s.GetToken(ParserGENERATED_, 0) 5698 } 5699 5700 func (s *Column_constraintContext) ALWAYS_() antlr.TerminalNode { 5701 return s.GetToken(ParserALWAYS_, 0) 5702 } 5703 5704 func (s *Column_constraintContext) STORED_() antlr.TerminalNode { 5705 return s.GetToken(ParserSTORED_, 0) 5706 } 5707 5708 func (s *Column_constraintContext) VIRTUAL_() antlr.TerminalNode { 5709 return s.GetToken(ParserVIRTUAL_, 0) 5710 } 5711 5712 func (s *Column_constraintContext) Asc_desc() IAsc_descContext { 5713 var t antlr.RuleContext 5714 for _, ctx := range s.GetChildren() { 5715 if _, ok := ctx.(IAsc_descContext); ok { 5716 t = ctx.(antlr.RuleContext) 5717 break 5718 } 5719 } 5720 5721 if t == nil { 5722 return nil 5723 } 5724 5725 return t.(IAsc_descContext) 5726 } 5727 5728 func (s *Column_constraintContext) AUTOINCREMENT_() antlr.TerminalNode { 5729 return s.GetToken(ParserAUTOINCREMENT_, 0) 5730 } 5731 5732 func (s *Column_constraintContext) GetRuleContext() antlr.RuleContext { 5733 return s 5734 } 5735 5736 func (s *Column_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 5737 return antlr.TreesStringTree(s, ruleNames, recog) 5738 } 5739 5740 func (s *Column_constraintContext) EnterRule(listener antlr.ParseTreeListener) { 5741 if listenerT, ok := listener.(ParserListener); ok { 5742 listenerT.EnterColumn_constraint(s) 5743 } 5744 } 5745 5746 func (s *Column_constraintContext) ExitRule(listener antlr.ParseTreeListener) { 5747 if listenerT, ok := listener.(ParserListener); ok { 5748 listenerT.ExitColumn_constraint(s) 5749 } 5750 } 5751 5752 func (s *Column_constraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 5753 switch t := visitor.(type) { 5754 case ParserVisitor: 5755 return t.VisitColumn_constraint(s) 5756 5757 default: 5758 return t.VisitChildren(s) 5759 } 5760 } 5761 5762 func (p *Parser) Column_constraint() (localctx IColumn_constraintContext) { 5763 this := p 5764 _ = this 5765 5766 localctx = NewColumn_constraintContext(p, p.GetParserRuleContext(), p.GetState()) 5767 p.EnterRule(localctx, 32, ParserRULE_column_constraint) 5768 var _la int 5769 5770 defer func() { 5771 p.ExitRule() 5772 }() 5773 5774 defer func() { 5775 if err := recover(); err != nil { 5776 if v, ok := err.(antlr.RecognitionException); ok { 5777 localctx.SetException(v) 5778 p.GetErrorHandler().ReportError(p, v) 5779 p.GetErrorHandler().Recover(p, v) 5780 } else { 5781 panic(err) 5782 } 5783 } 5784 }() 5785 5786 p.EnterOuterAlt(localctx, 1) 5787 p.SetState(488) 5788 p.GetErrorHandler().Sync(p) 5789 _la = p.GetTokenStream().LA(1) 5790 5791 if _la == ParserCONSTRAINT_ { 5792 { 5793 p.SetState(486) 5794 p.Match(ParserCONSTRAINT_) 5795 } 5796 { 5797 p.SetState(487) 5798 p.Name() 5799 } 5800 5801 } 5802 p.SetState(537) 5803 p.GetErrorHandler().Sync(p) 5804 5805 switch p.GetTokenStream().LA(1) { 5806 case ParserPRIMARY_: 5807 { 5808 p.SetState(490) 5809 p.Match(ParserPRIMARY_) 5810 } 5811 { 5812 p.SetState(491) 5813 p.Match(ParserKEY_) 5814 } 5815 p.SetState(493) 5816 p.GetErrorHandler().Sync(p) 5817 _la = p.GetTokenStream().LA(1) 5818 5819 if _la == ParserASC_ || _la == ParserDESC_ { 5820 { 5821 p.SetState(492) 5822 p.Asc_desc() 5823 } 5824 5825 } 5826 p.SetState(496) 5827 p.GetErrorHandler().Sync(p) 5828 _la = p.GetTokenStream().LA(1) 5829 5830 if _la == ParserON_ { 5831 { 5832 p.SetState(495) 5833 p.Conflict_clause() 5834 } 5835 5836 } 5837 p.SetState(499) 5838 p.GetErrorHandler().Sync(p) 5839 _la = p.GetTokenStream().LA(1) 5840 5841 if _la == ParserAUTOINCREMENT_ { 5842 { 5843 p.SetState(498) 5844 p.Match(ParserAUTOINCREMENT_) 5845 } 5846 5847 } 5848 5849 case ParserNOT_, ParserUNIQUE_: 5850 p.SetState(504) 5851 p.GetErrorHandler().Sync(p) 5852 5853 switch p.GetTokenStream().LA(1) { 5854 case ParserNOT_: 5855 { 5856 p.SetState(501) 5857 p.Match(ParserNOT_) 5858 } 5859 { 5860 p.SetState(502) 5861 p.Match(ParserNULL_) 5862 } 5863 5864 case ParserUNIQUE_: 5865 { 5866 p.SetState(503) 5867 p.Match(ParserUNIQUE_) 5868 } 5869 5870 default: 5871 panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) 5872 } 5873 p.SetState(507) 5874 p.GetErrorHandler().Sync(p) 5875 _la = p.GetTokenStream().LA(1) 5876 5877 if _la == ParserON_ { 5878 { 5879 p.SetState(506) 5880 p.Conflict_clause() 5881 } 5882 5883 } 5884 5885 case ParserCHECK_: 5886 { 5887 p.SetState(509) 5888 p.Match(ParserCHECK_) 5889 } 5890 { 5891 p.SetState(510) 5892 p.Match(ParserOPEN_PAR) 5893 } 5894 { 5895 p.SetState(511) 5896 p.expr(0) 5897 } 5898 { 5899 p.SetState(512) 5900 p.Match(ParserCLOSE_PAR) 5901 } 5902 5903 case ParserDEFAULT_: 5904 { 5905 p.SetState(514) 5906 p.Match(ParserDEFAULT_) 5907 } 5908 p.SetState(521) 5909 p.GetErrorHandler().Sync(p) 5910 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 50, p.GetParserRuleContext()) { 5911 case 1: 5912 { 5913 p.SetState(515) 5914 p.Signed_number() 5915 } 5916 5917 case 2: 5918 { 5919 p.SetState(516) 5920 p.Literal_value() 5921 } 5922 5923 case 3: 5924 { 5925 p.SetState(517) 5926 p.Match(ParserOPEN_PAR) 5927 } 5928 { 5929 p.SetState(518) 5930 p.expr(0) 5931 } 5932 { 5933 p.SetState(519) 5934 p.Match(ParserCLOSE_PAR) 5935 } 5936 5937 } 5938 5939 case ParserCOLLATE_: 5940 { 5941 p.SetState(523) 5942 p.Match(ParserCOLLATE_) 5943 } 5944 { 5945 p.SetState(524) 5946 p.Collation_name() 5947 } 5948 5949 case ParserREFERENCES_: 5950 { 5951 p.SetState(525) 5952 p.Foreign_key_clause() 5953 } 5954 5955 case ParserAS_, ParserGENERATED_: 5956 p.SetState(528) 5957 p.GetErrorHandler().Sync(p) 5958 _la = p.GetTokenStream().LA(1) 5959 5960 if _la == ParserGENERATED_ { 5961 { 5962 p.SetState(526) 5963 p.Match(ParserGENERATED_) 5964 } 5965 { 5966 p.SetState(527) 5967 p.Match(ParserALWAYS_) 5968 } 5969 5970 } 5971 { 5972 p.SetState(530) 5973 p.Match(ParserAS_) 5974 } 5975 { 5976 p.SetState(531) 5977 p.Match(ParserOPEN_PAR) 5978 } 5979 { 5980 p.SetState(532) 5981 p.expr(0) 5982 } 5983 { 5984 p.SetState(533) 5985 p.Match(ParserCLOSE_PAR) 5986 } 5987 p.SetState(535) 5988 p.GetErrorHandler().Sync(p) 5989 _la = p.GetTokenStream().LA(1) 5990 5991 if _la == ParserVIRTUAL_ || _la == ParserSTORED_ { 5992 { 5993 p.SetState(534) 5994 _la = p.GetTokenStream().LA(1) 5995 5996 if !(_la == ParserVIRTUAL_ || _la == ParserSTORED_) { 5997 p.GetErrorHandler().RecoverInline(p) 5998 } else { 5999 p.GetErrorHandler().ReportMatch(p) 6000 p.Consume() 6001 } 6002 } 6003 6004 } 6005 6006 default: 6007 panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) 6008 } 6009 6010 return localctx 6011 } 6012 6013 // ISigned_numberContext is an interface to support dynamic dispatch. 6014 type ISigned_numberContext interface { 6015 antlr.ParserRuleContext 6016 6017 // GetParser returns the parser. 6018 GetParser() antlr.Parser 6019 6020 // IsSigned_numberContext differentiates from other interfaces. 6021 IsSigned_numberContext() 6022 } 6023 6024 type Signed_numberContext struct { 6025 *antlr.BaseParserRuleContext 6026 parser antlr.Parser 6027 } 6028 6029 func NewEmptySigned_numberContext() *Signed_numberContext { 6030 var p = new(Signed_numberContext) 6031 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 6032 p.RuleIndex = ParserRULE_signed_number 6033 return p 6034 } 6035 6036 func (*Signed_numberContext) IsSigned_numberContext() {} 6037 6038 func NewSigned_numberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Signed_numberContext { 6039 var p = new(Signed_numberContext) 6040 6041 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 6042 6043 p.parser = parser 6044 p.RuleIndex = ParserRULE_signed_number 6045 6046 return p 6047 } 6048 6049 func (s *Signed_numberContext) GetParser() antlr.Parser { return s.parser } 6050 6051 func (s *Signed_numberContext) NUMERIC_LITERAL() antlr.TerminalNode { 6052 return s.GetToken(ParserNUMERIC_LITERAL, 0) 6053 } 6054 6055 func (s *Signed_numberContext) PLUS() antlr.TerminalNode { 6056 return s.GetToken(ParserPLUS, 0) 6057 } 6058 6059 func (s *Signed_numberContext) MINUS() antlr.TerminalNode { 6060 return s.GetToken(ParserMINUS, 0) 6061 } 6062 6063 func (s *Signed_numberContext) GetRuleContext() antlr.RuleContext { 6064 return s 6065 } 6066 6067 func (s *Signed_numberContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 6068 return antlr.TreesStringTree(s, ruleNames, recog) 6069 } 6070 6071 func (s *Signed_numberContext) EnterRule(listener antlr.ParseTreeListener) { 6072 if listenerT, ok := listener.(ParserListener); ok { 6073 listenerT.EnterSigned_number(s) 6074 } 6075 } 6076 6077 func (s *Signed_numberContext) ExitRule(listener antlr.ParseTreeListener) { 6078 if listenerT, ok := listener.(ParserListener); ok { 6079 listenerT.ExitSigned_number(s) 6080 } 6081 } 6082 6083 func (s *Signed_numberContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 6084 switch t := visitor.(type) { 6085 case ParserVisitor: 6086 return t.VisitSigned_number(s) 6087 6088 default: 6089 return t.VisitChildren(s) 6090 } 6091 } 6092 6093 func (p *Parser) Signed_number() (localctx ISigned_numberContext) { 6094 this := p 6095 _ = this 6096 6097 localctx = NewSigned_numberContext(p, p.GetParserRuleContext(), p.GetState()) 6098 p.EnterRule(localctx, 34, ParserRULE_signed_number) 6099 var _la int 6100 6101 defer func() { 6102 p.ExitRule() 6103 }() 6104 6105 defer func() { 6106 if err := recover(); err != nil { 6107 if v, ok := err.(antlr.RecognitionException); ok { 6108 localctx.SetException(v) 6109 p.GetErrorHandler().ReportError(p, v) 6110 p.GetErrorHandler().Recover(p, v) 6111 } else { 6112 panic(err) 6113 } 6114 } 6115 }() 6116 6117 p.EnterOuterAlt(localctx, 1) 6118 p.SetState(540) 6119 p.GetErrorHandler().Sync(p) 6120 _la = p.GetTokenStream().LA(1) 6121 6122 if _la == ParserPLUS || _la == ParserMINUS { 6123 { 6124 p.SetState(539) 6125 _la = p.GetTokenStream().LA(1) 6126 6127 if !(_la == ParserPLUS || _la == ParserMINUS) { 6128 p.GetErrorHandler().RecoverInline(p) 6129 } else { 6130 p.GetErrorHandler().ReportMatch(p) 6131 p.Consume() 6132 } 6133 } 6134 6135 } 6136 { 6137 p.SetState(542) 6138 p.Match(ParserNUMERIC_LITERAL) 6139 } 6140 6141 return localctx 6142 } 6143 6144 // ITable_constraintContext is an interface to support dynamic dispatch. 6145 type ITable_constraintContext interface { 6146 antlr.ParserRuleContext 6147 6148 // GetParser returns the parser. 6149 GetParser() antlr.Parser 6150 6151 // IsTable_constraintContext differentiates from other interfaces. 6152 IsTable_constraintContext() 6153 } 6154 6155 type Table_constraintContext struct { 6156 *antlr.BaseParserRuleContext 6157 parser antlr.Parser 6158 } 6159 6160 func NewEmptyTable_constraintContext() *Table_constraintContext { 6161 var p = new(Table_constraintContext) 6162 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 6163 p.RuleIndex = ParserRULE_table_constraint 6164 return p 6165 } 6166 6167 func (*Table_constraintContext) IsTable_constraintContext() {} 6168 6169 func NewTable_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_constraintContext { 6170 var p = new(Table_constraintContext) 6171 6172 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 6173 6174 p.parser = parser 6175 p.RuleIndex = ParserRULE_table_constraint 6176 6177 return p 6178 } 6179 6180 func (s *Table_constraintContext) GetParser() antlr.Parser { return s.parser } 6181 6182 func (s *Table_constraintContext) OPEN_PAR() antlr.TerminalNode { 6183 return s.GetToken(ParserOPEN_PAR, 0) 6184 } 6185 6186 func (s *Table_constraintContext) AllIndexed_column() []IIndexed_columnContext { 6187 children := s.GetChildren() 6188 len := 0 6189 for _, ctx := range children { 6190 if _, ok := ctx.(IIndexed_columnContext); ok { 6191 len++ 6192 } 6193 } 6194 6195 tst := make([]IIndexed_columnContext, len) 6196 i := 0 6197 for _, ctx := range children { 6198 if t, ok := ctx.(IIndexed_columnContext); ok { 6199 tst[i] = t.(IIndexed_columnContext) 6200 i++ 6201 } 6202 } 6203 6204 return tst 6205 } 6206 6207 func (s *Table_constraintContext) Indexed_column(i int) IIndexed_columnContext { 6208 var t antlr.RuleContext 6209 j := 0 6210 for _, ctx := range s.GetChildren() { 6211 if _, ok := ctx.(IIndexed_columnContext); ok { 6212 if j == i { 6213 t = ctx.(antlr.RuleContext) 6214 break 6215 } 6216 j++ 6217 } 6218 } 6219 6220 if t == nil { 6221 return nil 6222 } 6223 6224 return t.(IIndexed_columnContext) 6225 } 6226 6227 func (s *Table_constraintContext) CLOSE_PAR() antlr.TerminalNode { 6228 return s.GetToken(ParserCLOSE_PAR, 0) 6229 } 6230 6231 func (s *Table_constraintContext) CHECK_() antlr.TerminalNode { 6232 return s.GetToken(ParserCHECK_, 0) 6233 } 6234 6235 func (s *Table_constraintContext) Expr() IExprContext { 6236 var t antlr.RuleContext 6237 for _, ctx := range s.GetChildren() { 6238 if _, ok := ctx.(IExprContext); ok { 6239 t = ctx.(antlr.RuleContext) 6240 break 6241 } 6242 } 6243 6244 if t == nil { 6245 return nil 6246 } 6247 6248 return t.(IExprContext) 6249 } 6250 6251 func (s *Table_constraintContext) FOREIGN_() antlr.TerminalNode { 6252 return s.GetToken(ParserFOREIGN_, 0) 6253 } 6254 6255 func (s *Table_constraintContext) KEY_() antlr.TerminalNode { 6256 return s.GetToken(ParserKEY_, 0) 6257 } 6258 6259 func (s *Table_constraintContext) AllColumn_name() []IColumn_nameContext { 6260 children := s.GetChildren() 6261 len := 0 6262 for _, ctx := range children { 6263 if _, ok := ctx.(IColumn_nameContext); ok { 6264 len++ 6265 } 6266 } 6267 6268 tst := make([]IColumn_nameContext, len) 6269 i := 0 6270 for _, ctx := range children { 6271 if t, ok := ctx.(IColumn_nameContext); ok { 6272 tst[i] = t.(IColumn_nameContext) 6273 i++ 6274 } 6275 } 6276 6277 return tst 6278 } 6279 6280 func (s *Table_constraintContext) Column_name(i int) IColumn_nameContext { 6281 var t antlr.RuleContext 6282 j := 0 6283 for _, ctx := range s.GetChildren() { 6284 if _, ok := ctx.(IColumn_nameContext); ok { 6285 if j == i { 6286 t = ctx.(antlr.RuleContext) 6287 break 6288 } 6289 j++ 6290 } 6291 } 6292 6293 if t == nil { 6294 return nil 6295 } 6296 6297 return t.(IColumn_nameContext) 6298 } 6299 6300 func (s *Table_constraintContext) Foreign_key_clause() IForeign_key_clauseContext { 6301 var t antlr.RuleContext 6302 for _, ctx := range s.GetChildren() { 6303 if _, ok := ctx.(IForeign_key_clauseContext); ok { 6304 t = ctx.(antlr.RuleContext) 6305 break 6306 } 6307 } 6308 6309 if t == nil { 6310 return nil 6311 } 6312 6313 return t.(IForeign_key_clauseContext) 6314 } 6315 6316 func (s *Table_constraintContext) CONSTRAINT_() antlr.TerminalNode { 6317 return s.GetToken(ParserCONSTRAINT_, 0) 6318 } 6319 6320 func (s *Table_constraintContext) Name() INameContext { 6321 var t antlr.RuleContext 6322 for _, ctx := range s.GetChildren() { 6323 if _, ok := ctx.(INameContext); ok { 6324 t = ctx.(antlr.RuleContext) 6325 break 6326 } 6327 } 6328 6329 if t == nil { 6330 return nil 6331 } 6332 6333 return t.(INameContext) 6334 } 6335 6336 func (s *Table_constraintContext) PRIMARY_() antlr.TerminalNode { 6337 return s.GetToken(ParserPRIMARY_, 0) 6338 } 6339 6340 func (s *Table_constraintContext) UNIQUE_() antlr.TerminalNode { 6341 return s.GetToken(ParserUNIQUE_, 0) 6342 } 6343 6344 func (s *Table_constraintContext) AllCOMMA() []antlr.TerminalNode { 6345 return s.GetTokens(ParserCOMMA) 6346 } 6347 6348 func (s *Table_constraintContext) COMMA(i int) antlr.TerminalNode { 6349 return s.GetToken(ParserCOMMA, i) 6350 } 6351 6352 func (s *Table_constraintContext) Conflict_clause() IConflict_clauseContext { 6353 var t antlr.RuleContext 6354 for _, ctx := range s.GetChildren() { 6355 if _, ok := ctx.(IConflict_clauseContext); ok { 6356 t = ctx.(antlr.RuleContext) 6357 break 6358 } 6359 } 6360 6361 if t == nil { 6362 return nil 6363 } 6364 6365 return t.(IConflict_clauseContext) 6366 } 6367 6368 func (s *Table_constraintContext) GetRuleContext() antlr.RuleContext { 6369 return s 6370 } 6371 6372 func (s *Table_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 6373 return antlr.TreesStringTree(s, ruleNames, recog) 6374 } 6375 6376 func (s *Table_constraintContext) EnterRule(listener antlr.ParseTreeListener) { 6377 if listenerT, ok := listener.(ParserListener); ok { 6378 listenerT.EnterTable_constraint(s) 6379 } 6380 } 6381 6382 func (s *Table_constraintContext) ExitRule(listener antlr.ParseTreeListener) { 6383 if listenerT, ok := listener.(ParserListener); ok { 6384 listenerT.ExitTable_constraint(s) 6385 } 6386 } 6387 6388 func (s *Table_constraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 6389 switch t := visitor.(type) { 6390 case ParserVisitor: 6391 return t.VisitTable_constraint(s) 6392 6393 default: 6394 return t.VisitChildren(s) 6395 } 6396 } 6397 6398 func (p *Parser) Table_constraint() (localctx ITable_constraintContext) { 6399 this := p 6400 _ = this 6401 6402 localctx = NewTable_constraintContext(p, p.GetParserRuleContext(), p.GetState()) 6403 p.EnterRule(localctx, 36, ParserRULE_table_constraint) 6404 var _la int 6405 6406 defer func() { 6407 p.ExitRule() 6408 }() 6409 6410 defer func() { 6411 if err := recover(); err != nil { 6412 if v, ok := err.(antlr.RecognitionException); ok { 6413 localctx.SetException(v) 6414 p.GetErrorHandler().ReportError(p, v) 6415 p.GetErrorHandler().Recover(p, v) 6416 } else { 6417 panic(err) 6418 } 6419 } 6420 }() 6421 6422 p.EnterOuterAlt(localctx, 1) 6423 p.SetState(546) 6424 p.GetErrorHandler().Sync(p) 6425 _la = p.GetTokenStream().LA(1) 6426 6427 if _la == ParserCONSTRAINT_ { 6428 { 6429 p.SetState(544) 6430 p.Match(ParserCONSTRAINT_) 6431 } 6432 { 6433 p.SetState(545) 6434 p.Name() 6435 } 6436 6437 } 6438 p.SetState(585) 6439 p.GetErrorHandler().Sync(p) 6440 6441 switch p.GetTokenStream().LA(1) { 6442 case ParserPRIMARY_, ParserUNIQUE_: 6443 p.SetState(551) 6444 p.GetErrorHandler().Sync(p) 6445 6446 switch p.GetTokenStream().LA(1) { 6447 case ParserPRIMARY_: 6448 { 6449 p.SetState(548) 6450 p.Match(ParserPRIMARY_) 6451 } 6452 { 6453 p.SetState(549) 6454 p.Match(ParserKEY_) 6455 } 6456 6457 case ParserUNIQUE_: 6458 { 6459 p.SetState(550) 6460 p.Match(ParserUNIQUE_) 6461 } 6462 6463 default: 6464 panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) 6465 } 6466 { 6467 p.SetState(553) 6468 p.Match(ParserOPEN_PAR) 6469 } 6470 { 6471 p.SetState(554) 6472 p.Indexed_column() 6473 } 6474 p.SetState(559) 6475 p.GetErrorHandler().Sync(p) 6476 _la = p.GetTokenStream().LA(1) 6477 6478 for _la == ParserCOMMA { 6479 { 6480 p.SetState(555) 6481 p.Match(ParserCOMMA) 6482 } 6483 { 6484 p.SetState(556) 6485 p.Indexed_column() 6486 } 6487 6488 p.SetState(561) 6489 p.GetErrorHandler().Sync(p) 6490 _la = p.GetTokenStream().LA(1) 6491 } 6492 { 6493 p.SetState(562) 6494 p.Match(ParserCLOSE_PAR) 6495 } 6496 p.SetState(564) 6497 p.GetErrorHandler().Sync(p) 6498 _la = p.GetTokenStream().LA(1) 6499 6500 if _la == ParserON_ { 6501 { 6502 p.SetState(563) 6503 p.Conflict_clause() 6504 } 6505 6506 } 6507 6508 case ParserCHECK_: 6509 { 6510 p.SetState(566) 6511 p.Match(ParserCHECK_) 6512 } 6513 { 6514 p.SetState(567) 6515 p.Match(ParserOPEN_PAR) 6516 } 6517 { 6518 p.SetState(568) 6519 p.expr(0) 6520 } 6521 { 6522 p.SetState(569) 6523 p.Match(ParserCLOSE_PAR) 6524 } 6525 6526 case ParserFOREIGN_: 6527 { 6528 p.SetState(571) 6529 p.Match(ParserFOREIGN_) 6530 } 6531 { 6532 p.SetState(572) 6533 p.Match(ParserKEY_) 6534 } 6535 { 6536 p.SetState(573) 6537 p.Match(ParserOPEN_PAR) 6538 } 6539 { 6540 p.SetState(574) 6541 p.Column_name() 6542 } 6543 p.SetState(579) 6544 p.GetErrorHandler().Sync(p) 6545 _la = p.GetTokenStream().LA(1) 6546 6547 for _la == ParserCOMMA { 6548 { 6549 p.SetState(575) 6550 p.Match(ParserCOMMA) 6551 } 6552 { 6553 p.SetState(576) 6554 p.Column_name() 6555 } 6556 6557 p.SetState(581) 6558 p.GetErrorHandler().Sync(p) 6559 _la = p.GetTokenStream().LA(1) 6560 } 6561 { 6562 p.SetState(582) 6563 p.Match(ParserCLOSE_PAR) 6564 } 6565 { 6566 p.SetState(583) 6567 p.Foreign_key_clause() 6568 } 6569 6570 default: 6571 panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) 6572 } 6573 6574 return localctx 6575 } 6576 6577 // IForeign_key_clauseContext is an interface to support dynamic dispatch. 6578 type IForeign_key_clauseContext interface { 6579 antlr.ParserRuleContext 6580 6581 // GetParser returns the parser. 6582 GetParser() antlr.Parser 6583 6584 // IsForeign_key_clauseContext differentiates from other interfaces. 6585 IsForeign_key_clauseContext() 6586 } 6587 6588 type Foreign_key_clauseContext struct { 6589 *antlr.BaseParserRuleContext 6590 parser antlr.Parser 6591 } 6592 6593 func NewEmptyForeign_key_clauseContext() *Foreign_key_clauseContext { 6594 var p = new(Foreign_key_clauseContext) 6595 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 6596 p.RuleIndex = ParserRULE_foreign_key_clause 6597 return p 6598 } 6599 6600 func (*Foreign_key_clauseContext) IsForeign_key_clauseContext() {} 6601 6602 func NewForeign_key_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Foreign_key_clauseContext { 6603 var p = new(Foreign_key_clauseContext) 6604 6605 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 6606 6607 p.parser = parser 6608 p.RuleIndex = ParserRULE_foreign_key_clause 6609 6610 return p 6611 } 6612 6613 func (s *Foreign_key_clauseContext) GetParser() antlr.Parser { return s.parser } 6614 6615 func (s *Foreign_key_clauseContext) REFERENCES_() antlr.TerminalNode { 6616 return s.GetToken(ParserREFERENCES_, 0) 6617 } 6618 6619 func (s *Foreign_key_clauseContext) Foreign_table() IForeign_tableContext { 6620 var t antlr.RuleContext 6621 for _, ctx := range s.GetChildren() { 6622 if _, ok := ctx.(IForeign_tableContext); ok { 6623 t = ctx.(antlr.RuleContext) 6624 break 6625 } 6626 } 6627 6628 if t == nil { 6629 return nil 6630 } 6631 6632 return t.(IForeign_tableContext) 6633 } 6634 6635 func (s *Foreign_key_clauseContext) OPEN_PAR() antlr.TerminalNode { 6636 return s.GetToken(ParserOPEN_PAR, 0) 6637 } 6638 6639 func (s *Foreign_key_clauseContext) AllColumn_name() []IColumn_nameContext { 6640 children := s.GetChildren() 6641 len := 0 6642 for _, ctx := range children { 6643 if _, ok := ctx.(IColumn_nameContext); ok { 6644 len++ 6645 } 6646 } 6647 6648 tst := make([]IColumn_nameContext, len) 6649 i := 0 6650 for _, ctx := range children { 6651 if t, ok := ctx.(IColumn_nameContext); ok { 6652 tst[i] = t.(IColumn_nameContext) 6653 i++ 6654 } 6655 } 6656 6657 return tst 6658 } 6659 6660 func (s *Foreign_key_clauseContext) Column_name(i int) IColumn_nameContext { 6661 var t antlr.RuleContext 6662 j := 0 6663 for _, ctx := range s.GetChildren() { 6664 if _, ok := ctx.(IColumn_nameContext); ok { 6665 if j == i { 6666 t = ctx.(antlr.RuleContext) 6667 break 6668 } 6669 j++ 6670 } 6671 } 6672 6673 if t == nil { 6674 return nil 6675 } 6676 6677 return t.(IColumn_nameContext) 6678 } 6679 6680 func (s *Foreign_key_clauseContext) CLOSE_PAR() antlr.TerminalNode { 6681 return s.GetToken(ParserCLOSE_PAR, 0) 6682 } 6683 6684 func (s *Foreign_key_clauseContext) AllON_() []antlr.TerminalNode { 6685 return s.GetTokens(ParserON_) 6686 } 6687 6688 func (s *Foreign_key_clauseContext) ON_(i int) antlr.TerminalNode { 6689 return s.GetToken(ParserON_, i) 6690 } 6691 6692 func (s *Foreign_key_clauseContext) AllMATCH_() []antlr.TerminalNode { 6693 return s.GetTokens(ParserMATCH_) 6694 } 6695 6696 func (s *Foreign_key_clauseContext) MATCH_(i int) antlr.TerminalNode { 6697 return s.GetToken(ParserMATCH_, i) 6698 } 6699 6700 func (s *Foreign_key_clauseContext) AllName() []INameContext { 6701 children := s.GetChildren() 6702 len := 0 6703 for _, ctx := range children { 6704 if _, ok := ctx.(INameContext); ok { 6705 len++ 6706 } 6707 } 6708 6709 tst := make([]INameContext, len) 6710 i := 0 6711 for _, ctx := range children { 6712 if t, ok := ctx.(INameContext); ok { 6713 tst[i] = t.(INameContext) 6714 i++ 6715 } 6716 } 6717 6718 return tst 6719 } 6720 6721 func (s *Foreign_key_clauseContext) Name(i int) INameContext { 6722 var t antlr.RuleContext 6723 j := 0 6724 for _, ctx := range s.GetChildren() { 6725 if _, ok := ctx.(INameContext); ok { 6726 if j == i { 6727 t = ctx.(antlr.RuleContext) 6728 break 6729 } 6730 j++ 6731 } 6732 } 6733 6734 if t == nil { 6735 return nil 6736 } 6737 6738 return t.(INameContext) 6739 } 6740 6741 func (s *Foreign_key_clauseContext) DEFERRABLE_() antlr.TerminalNode { 6742 return s.GetToken(ParserDEFERRABLE_, 0) 6743 } 6744 6745 func (s *Foreign_key_clauseContext) AllDELETE_() []antlr.TerminalNode { 6746 return s.GetTokens(ParserDELETE_) 6747 } 6748 6749 func (s *Foreign_key_clauseContext) DELETE_(i int) antlr.TerminalNode { 6750 return s.GetToken(ParserDELETE_, i) 6751 } 6752 6753 func (s *Foreign_key_clauseContext) AllUPDATE_() []antlr.TerminalNode { 6754 return s.GetTokens(ParserUPDATE_) 6755 } 6756 6757 func (s *Foreign_key_clauseContext) UPDATE_(i int) antlr.TerminalNode { 6758 return s.GetToken(ParserUPDATE_, i) 6759 } 6760 6761 func (s *Foreign_key_clauseContext) AllSET_() []antlr.TerminalNode { 6762 return s.GetTokens(ParserSET_) 6763 } 6764 6765 func (s *Foreign_key_clauseContext) SET_(i int) antlr.TerminalNode { 6766 return s.GetToken(ParserSET_, i) 6767 } 6768 6769 func (s *Foreign_key_clauseContext) AllCASCADE_() []antlr.TerminalNode { 6770 return s.GetTokens(ParserCASCADE_) 6771 } 6772 6773 func (s *Foreign_key_clauseContext) CASCADE_(i int) antlr.TerminalNode { 6774 return s.GetToken(ParserCASCADE_, i) 6775 } 6776 6777 func (s *Foreign_key_clauseContext) AllRESTRICT_() []antlr.TerminalNode { 6778 return s.GetTokens(ParserRESTRICT_) 6779 } 6780 6781 func (s *Foreign_key_clauseContext) RESTRICT_(i int) antlr.TerminalNode { 6782 return s.GetToken(ParserRESTRICT_, i) 6783 } 6784 6785 func (s *Foreign_key_clauseContext) AllNO_() []antlr.TerminalNode { 6786 return s.GetTokens(ParserNO_) 6787 } 6788 6789 func (s *Foreign_key_clauseContext) NO_(i int) antlr.TerminalNode { 6790 return s.GetToken(ParserNO_, i) 6791 } 6792 6793 func (s *Foreign_key_clauseContext) AllACTION_() []antlr.TerminalNode { 6794 return s.GetTokens(ParserACTION_) 6795 } 6796 6797 func (s *Foreign_key_clauseContext) ACTION_(i int) antlr.TerminalNode { 6798 return s.GetToken(ParserACTION_, i) 6799 } 6800 6801 func (s *Foreign_key_clauseContext) AllCOMMA() []antlr.TerminalNode { 6802 return s.GetTokens(ParserCOMMA) 6803 } 6804 6805 func (s *Foreign_key_clauseContext) COMMA(i int) antlr.TerminalNode { 6806 return s.GetToken(ParserCOMMA, i) 6807 } 6808 6809 func (s *Foreign_key_clauseContext) AllNULL_() []antlr.TerminalNode { 6810 return s.GetTokens(ParserNULL_) 6811 } 6812 6813 func (s *Foreign_key_clauseContext) NULL_(i int) antlr.TerminalNode { 6814 return s.GetToken(ParserNULL_, i) 6815 } 6816 6817 func (s *Foreign_key_clauseContext) AllDEFAULT_() []antlr.TerminalNode { 6818 return s.GetTokens(ParserDEFAULT_) 6819 } 6820 6821 func (s *Foreign_key_clauseContext) DEFAULT_(i int) antlr.TerminalNode { 6822 return s.GetToken(ParserDEFAULT_, i) 6823 } 6824 6825 func (s *Foreign_key_clauseContext) NOT_() antlr.TerminalNode { 6826 return s.GetToken(ParserNOT_, 0) 6827 } 6828 6829 func (s *Foreign_key_clauseContext) INITIALLY_() antlr.TerminalNode { 6830 return s.GetToken(ParserINITIALLY_, 0) 6831 } 6832 6833 func (s *Foreign_key_clauseContext) DEFERRED_() antlr.TerminalNode { 6834 return s.GetToken(ParserDEFERRED_, 0) 6835 } 6836 6837 func (s *Foreign_key_clauseContext) IMMEDIATE_() antlr.TerminalNode { 6838 return s.GetToken(ParserIMMEDIATE_, 0) 6839 } 6840 6841 func (s *Foreign_key_clauseContext) GetRuleContext() antlr.RuleContext { 6842 return s 6843 } 6844 6845 func (s *Foreign_key_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 6846 return antlr.TreesStringTree(s, ruleNames, recog) 6847 } 6848 6849 func (s *Foreign_key_clauseContext) EnterRule(listener antlr.ParseTreeListener) { 6850 if listenerT, ok := listener.(ParserListener); ok { 6851 listenerT.EnterForeign_key_clause(s) 6852 } 6853 } 6854 6855 func (s *Foreign_key_clauseContext) ExitRule(listener antlr.ParseTreeListener) { 6856 if listenerT, ok := listener.(ParserListener); ok { 6857 listenerT.ExitForeign_key_clause(s) 6858 } 6859 } 6860 6861 func (s *Foreign_key_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 6862 switch t := visitor.(type) { 6863 case ParserVisitor: 6864 return t.VisitForeign_key_clause(s) 6865 6866 default: 6867 return t.VisitChildren(s) 6868 } 6869 } 6870 6871 func (p *Parser) Foreign_key_clause() (localctx IForeign_key_clauseContext) { 6872 this := p 6873 _ = this 6874 6875 localctx = NewForeign_key_clauseContext(p, p.GetParserRuleContext(), p.GetState()) 6876 p.EnterRule(localctx, 38, ParserRULE_foreign_key_clause) 6877 var _la int 6878 6879 defer func() { 6880 p.ExitRule() 6881 }() 6882 6883 defer func() { 6884 if err := recover(); err != nil { 6885 if v, ok := err.(antlr.RecognitionException); ok { 6886 localctx.SetException(v) 6887 p.GetErrorHandler().ReportError(p, v) 6888 p.GetErrorHandler().Recover(p, v) 6889 } else { 6890 panic(err) 6891 } 6892 } 6893 }() 6894 6895 p.EnterOuterAlt(localctx, 1) 6896 { 6897 p.SetState(587) 6898 p.Match(ParserREFERENCES_) 6899 } 6900 { 6901 p.SetState(588) 6902 p.Foreign_table() 6903 } 6904 p.SetState(600) 6905 p.GetErrorHandler().Sync(p) 6906 _la = p.GetTokenStream().LA(1) 6907 6908 if _la == ParserOPEN_PAR { 6909 { 6910 p.SetState(589) 6911 p.Match(ParserOPEN_PAR) 6912 } 6913 { 6914 p.SetState(590) 6915 p.Column_name() 6916 } 6917 p.SetState(595) 6918 p.GetErrorHandler().Sync(p) 6919 _la = p.GetTokenStream().LA(1) 6920 6921 for _la == ParserCOMMA { 6922 { 6923 p.SetState(591) 6924 p.Match(ParserCOMMA) 6925 } 6926 { 6927 p.SetState(592) 6928 p.Column_name() 6929 } 6930 6931 p.SetState(597) 6932 p.GetErrorHandler().Sync(p) 6933 _la = p.GetTokenStream().LA(1) 6934 } 6935 { 6936 p.SetState(598) 6937 p.Match(ParserCLOSE_PAR) 6938 } 6939 6940 } 6941 p.SetState(616) 6942 p.GetErrorHandler().Sync(p) 6943 _la = p.GetTokenStream().LA(1) 6944 6945 for _la == ParserMATCH_ || _la == ParserON_ { 6946 p.SetState(614) 6947 p.GetErrorHandler().Sync(p) 6948 6949 switch p.GetTokenStream().LA(1) { 6950 case ParserON_: 6951 { 6952 p.SetState(602) 6953 p.Match(ParserON_) 6954 } 6955 { 6956 p.SetState(603) 6957 _la = p.GetTokenStream().LA(1) 6958 6959 if !(_la == ParserDELETE_ || _la == ParserUPDATE_) { 6960 p.GetErrorHandler().RecoverInline(p) 6961 } else { 6962 p.GetErrorHandler().ReportMatch(p) 6963 p.Consume() 6964 } 6965 } 6966 p.SetState(610) 6967 p.GetErrorHandler().Sync(p) 6968 6969 switch p.GetTokenStream().LA(1) { 6970 case ParserSET_: 6971 { 6972 p.SetState(604) 6973 p.Match(ParserSET_) 6974 } 6975 { 6976 p.SetState(605) 6977 _la = p.GetTokenStream().LA(1) 6978 6979 if !(_la == ParserDEFAULT_ || _la == ParserNULL_) { 6980 p.GetErrorHandler().RecoverInline(p) 6981 } else { 6982 p.GetErrorHandler().ReportMatch(p) 6983 p.Consume() 6984 } 6985 } 6986 6987 case ParserCASCADE_: 6988 { 6989 p.SetState(606) 6990 p.Match(ParserCASCADE_) 6991 } 6992 6993 case ParserRESTRICT_: 6994 { 6995 p.SetState(607) 6996 p.Match(ParserRESTRICT_) 6997 } 6998 6999 case ParserNO_: 7000 { 7001 p.SetState(608) 7002 p.Match(ParserNO_) 7003 } 7004 { 7005 p.SetState(609) 7006 p.Match(ParserACTION_) 7007 } 7008 7009 default: 7010 panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) 7011 } 7012 7013 case ParserMATCH_: 7014 { 7015 p.SetState(612) 7016 p.Match(ParserMATCH_) 7017 } 7018 { 7019 p.SetState(613) 7020 p.Name() 7021 } 7022 7023 default: 7024 panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) 7025 } 7026 7027 p.SetState(618) 7028 p.GetErrorHandler().Sync(p) 7029 _la = p.GetTokenStream().LA(1) 7030 } 7031 p.SetState(627) 7032 p.GetErrorHandler().Sync(p) 7033 7034 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 68, p.GetParserRuleContext()) == 1 { 7035 p.SetState(620) 7036 p.GetErrorHandler().Sync(p) 7037 _la = p.GetTokenStream().LA(1) 7038 7039 if _la == ParserNOT_ { 7040 { 7041 p.SetState(619) 7042 p.Match(ParserNOT_) 7043 } 7044 7045 } 7046 { 7047 p.SetState(622) 7048 p.Match(ParserDEFERRABLE_) 7049 } 7050 p.SetState(625) 7051 p.GetErrorHandler().Sync(p) 7052 _la = p.GetTokenStream().LA(1) 7053 7054 if _la == ParserINITIALLY_ { 7055 { 7056 p.SetState(623) 7057 p.Match(ParserINITIALLY_) 7058 } 7059 { 7060 p.SetState(624) 7061 _la = p.GetTokenStream().LA(1) 7062 7063 if !(_la == ParserDEFERRED_ || _la == ParserIMMEDIATE_) { 7064 p.GetErrorHandler().RecoverInline(p) 7065 } else { 7066 p.GetErrorHandler().ReportMatch(p) 7067 p.Consume() 7068 } 7069 } 7070 7071 } 7072 7073 } 7074 7075 return localctx 7076 } 7077 7078 // IConflict_clauseContext is an interface to support dynamic dispatch. 7079 type IConflict_clauseContext interface { 7080 antlr.ParserRuleContext 7081 7082 // GetParser returns the parser. 7083 GetParser() antlr.Parser 7084 7085 // IsConflict_clauseContext differentiates from other interfaces. 7086 IsConflict_clauseContext() 7087 } 7088 7089 type Conflict_clauseContext struct { 7090 *antlr.BaseParserRuleContext 7091 parser antlr.Parser 7092 } 7093 7094 func NewEmptyConflict_clauseContext() *Conflict_clauseContext { 7095 var p = new(Conflict_clauseContext) 7096 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 7097 p.RuleIndex = ParserRULE_conflict_clause 7098 return p 7099 } 7100 7101 func (*Conflict_clauseContext) IsConflict_clauseContext() {} 7102 7103 func NewConflict_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Conflict_clauseContext { 7104 var p = new(Conflict_clauseContext) 7105 7106 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 7107 7108 p.parser = parser 7109 p.RuleIndex = ParserRULE_conflict_clause 7110 7111 return p 7112 } 7113 7114 func (s *Conflict_clauseContext) GetParser() antlr.Parser { return s.parser } 7115 7116 func (s *Conflict_clauseContext) ON_() antlr.TerminalNode { 7117 return s.GetToken(ParserON_, 0) 7118 } 7119 7120 func (s *Conflict_clauseContext) CONFLICT_() antlr.TerminalNode { 7121 return s.GetToken(ParserCONFLICT_, 0) 7122 } 7123 7124 func (s *Conflict_clauseContext) ROLLBACK_() antlr.TerminalNode { 7125 return s.GetToken(ParserROLLBACK_, 0) 7126 } 7127 7128 func (s *Conflict_clauseContext) ABORT_() antlr.TerminalNode { 7129 return s.GetToken(ParserABORT_, 0) 7130 } 7131 7132 func (s *Conflict_clauseContext) FAIL_() antlr.TerminalNode { 7133 return s.GetToken(ParserFAIL_, 0) 7134 } 7135 7136 func (s *Conflict_clauseContext) IGNORE_() antlr.TerminalNode { 7137 return s.GetToken(ParserIGNORE_, 0) 7138 } 7139 7140 func (s *Conflict_clauseContext) REPLACE_() antlr.TerminalNode { 7141 return s.GetToken(ParserREPLACE_, 0) 7142 } 7143 7144 func (s *Conflict_clauseContext) GetRuleContext() antlr.RuleContext { 7145 return s 7146 } 7147 7148 func (s *Conflict_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 7149 return antlr.TreesStringTree(s, ruleNames, recog) 7150 } 7151 7152 func (s *Conflict_clauseContext) EnterRule(listener antlr.ParseTreeListener) { 7153 if listenerT, ok := listener.(ParserListener); ok { 7154 listenerT.EnterConflict_clause(s) 7155 } 7156 } 7157 7158 func (s *Conflict_clauseContext) ExitRule(listener antlr.ParseTreeListener) { 7159 if listenerT, ok := listener.(ParserListener); ok { 7160 listenerT.ExitConflict_clause(s) 7161 } 7162 } 7163 7164 func (s *Conflict_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 7165 switch t := visitor.(type) { 7166 case ParserVisitor: 7167 return t.VisitConflict_clause(s) 7168 7169 default: 7170 return t.VisitChildren(s) 7171 } 7172 } 7173 7174 func (p *Parser) Conflict_clause() (localctx IConflict_clauseContext) { 7175 this := p 7176 _ = this 7177 7178 localctx = NewConflict_clauseContext(p, p.GetParserRuleContext(), p.GetState()) 7179 p.EnterRule(localctx, 40, ParserRULE_conflict_clause) 7180 var _la int 7181 7182 defer func() { 7183 p.ExitRule() 7184 }() 7185 7186 defer func() { 7187 if err := recover(); err != nil { 7188 if v, ok := err.(antlr.RecognitionException); ok { 7189 localctx.SetException(v) 7190 p.GetErrorHandler().ReportError(p, v) 7191 p.GetErrorHandler().Recover(p, v) 7192 } else { 7193 panic(err) 7194 } 7195 } 7196 }() 7197 7198 p.EnterOuterAlt(localctx, 1) 7199 { 7200 p.SetState(629) 7201 p.Match(ParserON_) 7202 } 7203 { 7204 p.SetState(630) 7205 p.Match(ParserCONFLICT_) 7206 } 7207 { 7208 p.SetState(631) 7209 _la = p.GetTokenStream().LA(1) 7210 7211 if !(_la == ParserABORT_ || _la == ParserFAIL_ || _la == ParserIGNORE_ || _la == ParserREPLACE_ || _la == ParserROLLBACK_) { 7212 p.GetErrorHandler().RecoverInline(p) 7213 } else { 7214 p.GetErrorHandler().ReportMatch(p) 7215 p.Consume() 7216 } 7217 } 7218 7219 return localctx 7220 } 7221 7222 // ICreate_trigger_stmtContext is an interface to support dynamic dispatch. 7223 type ICreate_trigger_stmtContext interface { 7224 antlr.ParserRuleContext 7225 7226 // GetParser returns the parser. 7227 GetParser() antlr.Parser 7228 7229 // IsCreate_trigger_stmtContext differentiates from other interfaces. 7230 IsCreate_trigger_stmtContext() 7231 } 7232 7233 type Create_trigger_stmtContext struct { 7234 *antlr.BaseParserRuleContext 7235 parser antlr.Parser 7236 } 7237 7238 func NewEmptyCreate_trigger_stmtContext() *Create_trigger_stmtContext { 7239 var p = new(Create_trigger_stmtContext) 7240 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 7241 p.RuleIndex = ParserRULE_create_trigger_stmt 7242 return p 7243 } 7244 7245 func (*Create_trigger_stmtContext) IsCreate_trigger_stmtContext() {} 7246 7247 func NewCreate_trigger_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_trigger_stmtContext { 7248 var p = new(Create_trigger_stmtContext) 7249 7250 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 7251 7252 p.parser = parser 7253 p.RuleIndex = ParserRULE_create_trigger_stmt 7254 7255 return p 7256 } 7257 7258 func (s *Create_trigger_stmtContext) GetParser() antlr.Parser { return s.parser } 7259 7260 func (s *Create_trigger_stmtContext) CREATE_() antlr.TerminalNode { 7261 return s.GetToken(ParserCREATE_, 0) 7262 } 7263 7264 func (s *Create_trigger_stmtContext) TRIGGER_() antlr.TerminalNode { 7265 return s.GetToken(ParserTRIGGER_, 0) 7266 } 7267 7268 func (s *Create_trigger_stmtContext) Trigger_name() ITrigger_nameContext { 7269 var t antlr.RuleContext 7270 for _, ctx := range s.GetChildren() { 7271 if _, ok := ctx.(ITrigger_nameContext); ok { 7272 t = ctx.(antlr.RuleContext) 7273 break 7274 } 7275 } 7276 7277 if t == nil { 7278 return nil 7279 } 7280 7281 return t.(ITrigger_nameContext) 7282 } 7283 7284 func (s *Create_trigger_stmtContext) ON_() antlr.TerminalNode { 7285 return s.GetToken(ParserON_, 0) 7286 } 7287 7288 func (s *Create_trigger_stmtContext) Table_name() ITable_nameContext { 7289 var t antlr.RuleContext 7290 for _, ctx := range s.GetChildren() { 7291 if _, ok := ctx.(ITable_nameContext); ok { 7292 t = ctx.(antlr.RuleContext) 7293 break 7294 } 7295 } 7296 7297 if t == nil { 7298 return nil 7299 } 7300 7301 return t.(ITable_nameContext) 7302 } 7303 7304 func (s *Create_trigger_stmtContext) BEGIN_() antlr.TerminalNode { 7305 return s.GetToken(ParserBEGIN_, 0) 7306 } 7307 7308 func (s *Create_trigger_stmtContext) END_() antlr.TerminalNode { 7309 return s.GetToken(ParserEND_, 0) 7310 } 7311 7312 func (s *Create_trigger_stmtContext) DELETE_() antlr.TerminalNode { 7313 return s.GetToken(ParserDELETE_, 0) 7314 } 7315 7316 func (s *Create_trigger_stmtContext) INSERT_() antlr.TerminalNode { 7317 return s.GetToken(ParserINSERT_, 0) 7318 } 7319 7320 func (s *Create_trigger_stmtContext) UPDATE_() antlr.TerminalNode { 7321 return s.GetToken(ParserUPDATE_, 0) 7322 } 7323 7324 func (s *Create_trigger_stmtContext) IF_() antlr.TerminalNode { 7325 return s.GetToken(ParserIF_, 0) 7326 } 7327 7328 func (s *Create_trigger_stmtContext) NOT_() antlr.TerminalNode { 7329 return s.GetToken(ParserNOT_, 0) 7330 } 7331 7332 func (s *Create_trigger_stmtContext) EXISTS_() antlr.TerminalNode { 7333 return s.GetToken(ParserEXISTS_, 0) 7334 } 7335 7336 func (s *Create_trigger_stmtContext) Schema_name() ISchema_nameContext { 7337 var t antlr.RuleContext 7338 for _, ctx := range s.GetChildren() { 7339 if _, ok := ctx.(ISchema_nameContext); ok { 7340 t = ctx.(antlr.RuleContext) 7341 break 7342 } 7343 } 7344 7345 if t == nil { 7346 return nil 7347 } 7348 7349 return t.(ISchema_nameContext) 7350 } 7351 7352 func (s *Create_trigger_stmtContext) DOT() antlr.TerminalNode { 7353 return s.GetToken(ParserDOT, 0) 7354 } 7355 7356 func (s *Create_trigger_stmtContext) BEFORE_() antlr.TerminalNode { 7357 return s.GetToken(ParserBEFORE_, 0) 7358 } 7359 7360 func (s *Create_trigger_stmtContext) AFTER_() antlr.TerminalNode { 7361 return s.GetToken(ParserAFTER_, 0) 7362 } 7363 7364 func (s *Create_trigger_stmtContext) INSTEAD_() antlr.TerminalNode { 7365 return s.GetToken(ParserINSTEAD_, 0) 7366 } 7367 7368 func (s *Create_trigger_stmtContext) AllOF_() []antlr.TerminalNode { 7369 return s.GetTokens(ParserOF_) 7370 } 7371 7372 func (s *Create_trigger_stmtContext) OF_(i int) antlr.TerminalNode { 7373 return s.GetToken(ParserOF_, i) 7374 } 7375 7376 func (s *Create_trigger_stmtContext) FOR_() antlr.TerminalNode { 7377 return s.GetToken(ParserFOR_, 0) 7378 } 7379 7380 func (s *Create_trigger_stmtContext) EACH_() antlr.TerminalNode { 7381 return s.GetToken(ParserEACH_, 0) 7382 } 7383 7384 func (s *Create_trigger_stmtContext) ROW_() antlr.TerminalNode { 7385 return s.GetToken(ParserROW_, 0) 7386 } 7387 7388 func (s *Create_trigger_stmtContext) WHEN_() antlr.TerminalNode { 7389 return s.GetToken(ParserWHEN_, 0) 7390 } 7391 7392 func (s *Create_trigger_stmtContext) Expr() IExprContext { 7393 var t antlr.RuleContext 7394 for _, ctx := range s.GetChildren() { 7395 if _, ok := ctx.(IExprContext); ok { 7396 t = ctx.(antlr.RuleContext) 7397 break 7398 } 7399 } 7400 7401 if t == nil { 7402 return nil 7403 } 7404 7405 return t.(IExprContext) 7406 } 7407 7408 func (s *Create_trigger_stmtContext) AllSCOL() []antlr.TerminalNode { 7409 return s.GetTokens(ParserSCOL) 7410 } 7411 7412 func (s *Create_trigger_stmtContext) SCOL(i int) antlr.TerminalNode { 7413 return s.GetToken(ParserSCOL, i) 7414 } 7415 7416 func (s *Create_trigger_stmtContext) TEMP_() antlr.TerminalNode { 7417 return s.GetToken(ParserTEMP_, 0) 7418 } 7419 7420 func (s *Create_trigger_stmtContext) TEMPORARY_() antlr.TerminalNode { 7421 return s.GetToken(ParserTEMPORARY_, 0) 7422 } 7423 7424 func (s *Create_trigger_stmtContext) AllColumn_name() []IColumn_nameContext { 7425 children := s.GetChildren() 7426 len := 0 7427 for _, ctx := range children { 7428 if _, ok := ctx.(IColumn_nameContext); ok { 7429 len++ 7430 } 7431 } 7432 7433 tst := make([]IColumn_nameContext, len) 7434 i := 0 7435 for _, ctx := range children { 7436 if t, ok := ctx.(IColumn_nameContext); ok { 7437 tst[i] = t.(IColumn_nameContext) 7438 i++ 7439 } 7440 } 7441 7442 return tst 7443 } 7444 7445 func (s *Create_trigger_stmtContext) Column_name(i int) IColumn_nameContext { 7446 var t antlr.RuleContext 7447 j := 0 7448 for _, ctx := range s.GetChildren() { 7449 if _, ok := ctx.(IColumn_nameContext); ok { 7450 if j == i { 7451 t = ctx.(antlr.RuleContext) 7452 break 7453 } 7454 j++ 7455 } 7456 } 7457 7458 if t == nil { 7459 return nil 7460 } 7461 7462 return t.(IColumn_nameContext) 7463 } 7464 7465 func (s *Create_trigger_stmtContext) AllUpdate_stmt() []IUpdate_stmtContext { 7466 children := s.GetChildren() 7467 len := 0 7468 for _, ctx := range children { 7469 if _, ok := ctx.(IUpdate_stmtContext); ok { 7470 len++ 7471 } 7472 } 7473 7474 tst := make([]IUpdate_stmtContext, len) 7475 i := 0 7476 for _, ctx := range children { 7477 if t, ok := ctx.(IUpdate_stmtContext); ok { 7478 tst[i] = t.(IUpdate_stmtContext) 7479 i++ 7480 } 7481 } 7482 7483 return tst 7484 } 7485 7486 func (s *Create_trigger_stmtContext) Update_stmt(i int) IUpdate_stmtContext { 7487 var t antlr.RuleContext 7488 j := 0 7489 for _, ctx := range s.GetChildren() { 7490 if _, ok := ctx.(IUpdate_stmtContext); ok { 7491 if j == i { 7492 t = ctx.(antlr.RuleContext) 7493 break 7494 } 7495 j++ 7496 } 7497 } 7498 7499 if t == nil { 7500 return nil 7501 } 7502 7503 return t.(IUpdate_stmtContext) 7504 } 7505 7506 func (s *Create_trigger_stmtContext) AllInsert_stmt() []IInsert_stmtContext { 7507 children := s.GetChildren() 7508 len := 0 7509 for _, ctx := range children { 7510 if _, ok := ctx.(IInsert_stmtContext); ok { 7511 len++ 7512 } 7513 } 7514 7515 tst := make([]IInsert_stmtContext, len) 7516 i := 0 7517 for _, ctx := range children { 7518 if t, ok := ctx.(IInsert_stmtContext); ok { 7519 tst[i] = t.(IInsert_stmtContext) 7520 i++ 7521 } 7522 } 7523 7524 return tst 7525 } 7526 7527 func (s *Create_trigger_stmtContext) Insert_stmt(i int) IInsert_stmtContext { 7528 var t antlr.RuleContext 7529 j := 0 7530 for _, ctx := range s.GetChildren() { 7531 if _, ok := ctx.(IInsert_stmtContext); ok { 7532 if j == i { 7533 t = ctx.(antlr.RuleContext) 7534 break 7535 } 7536 j++ 7537 } 7538 } 7539 7540 if t == nil { 7541 return nil 7542 } 7543 7544 return t.(IInsert_stmtContext) 7545 } 7546 7547 func (s *Create_trigger_stmtContext) AllDelete_stmt() []IDelete_stmtContext { 7548 children := s.GetChildren() 7549 len := 0 7550 for _, ctx := range children { 7551 if _, ok := ctx.(IDelete_stmtContext); ok { 7552 len++ 7553 } 7554 } 7555 7556 tst := make([]IDelete_stmtContext, len) 7557 i := 0 7558 for _, ctx := range children { 7559 if t, ok := ctx.(IDelete_stmtContext); ok { 7560 tst[i] = t.(IDelete_stmtContext) 7561 i++ 7562 } 7563 } 7564 7565 return tst 7566 } 7567 7568 func (s *Create_trigger_stmtContext) Delete_stmt(i int) IDelete_stmtContext { 7569 var t antlr.RuleContext 7570 j := 0 7571 for _, ctx := range s.GetChildren() { 7572 if _, ok := ctx.(IDelete_stmtContext); ok { 7573 if j == i { 7574 t = ctx.(antlr.RuleContext) 7575 break 7576 } 7577 j++ 7578 } 7579 } 7580 7581 if t == nil { 7582 return nil 7583 } 7584 7585 return t.(IDelete_stmtContext) 7586 } 7587 7588 func (s *Create_trigger_stmtContext) AllSelect_stmt() []ISelect_stmtContext { 7589 children := s.GetChildren() 7590 len := 0 7591 for _, ctx := range children { 7592 if _, ok := ctx.(ISelect_stmtContext); ok { 7593 len++ 7594 } 7595 } 7596 7597 tst := make([]ISelect_stmtContext, len) 7598 i := 0 7599 for _, ctx := range children { 7600 if t, ok := ctx.(ISelect_stmtContext); ok { 7601 tst[i] = t.(ISelect_stmtContext) 7602 i++ 7603 } 7604 } 7605 7606 return tst 7607 } 7608 7609 func (s *Create_trigger_stmtContext) Select_stmt(i int) ISelect_stmtContext { 7610 var t antlr.RuleContext 7611 j := 0 7612 for _, ctx := range s.GetChildren() { 7613 if _, ok := ctx.(ISelect_stmtContext); ok { 7614 if j == i { 7615 t = ctx.(antlr.RuleContext) 7616 break 7617 } 7618 j++ 7619 } 7620 } 7621 7622 if t == nil { 7623 return nil 7624 } 7625 7626 return t.(ISelect_stmtContext) 7627 } 7628 7629 func (s *Create_trigger_stmtContext) AllCOMMA() []antlr.TerminalNode { 7630 return s.GetTokens(ParserCOMMA) 7631 } 7632 7633 func (s *Create_trigger_stmtContext) COMMA(i int) antlr.TerminalNode { 7634 return s.GetToken(ParserCOMMA, i) 7635 } 7636 7637 func (s *Create_trigger_stmtContext) GetRuleContext() antlr.RuleContext { 7638 return s 7639 } 7640 7641 func (s *Create_trigger_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 7642 return antlr.TreesStringTree(s, ruleNames, recog) 7643 } 7644 7645 func (s *Create_trigger_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 7646 if listenerT, ok := listener.(ParserListener); ok { 7647 listenerT.EnterCreate_trigger_stmt(s) 7648 } 7649 } 7650 7651 func (s *Create_trigger_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 7652 if listenerT, ok := listener.(ParserListener); ok { 7653 listenerT.ExitCreate_trigger_stmt(s) 7654 } 7655 } 7656 7657 func (s *Create_trigger_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 7658 switch t := visitor.(type) { 7659 case ParserVisitor: 7660 return t.VisitCreate_trigger_stmt(s) 7661 7662 default: 7663 return t.VisitChildren(s) 7664 } 7665 } 7666 7667 func (p *Parser) Create_trigger_stmt() (localctx ICreate_trigger_stmtContext) { 7668 this := p 7669 _ = this 7670 7671 localctx = NewCreate_trigger_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 7672 p.EnterRule(localctx, 42, ParserRULE_create_trigger_stmt) 7673 var _la int 7674 7675 defer func() { 7676 p.ExitRule() 7677 }() 7678 7679 defer func() { 7680 if err := recover(); err != nil { 7681 if v, ok := err.(antlr.RecognitionException); ok { 7682 localctx.SetException(v) 7683 p.GetErrorHandler().ReportError(p, v) 7684 p.GetErrorHandler().Recover(p, v) 7685 } else { 7686 panic(err) 7687 } 7688 } 7689 }() 7690 7691 p.EnterOuterAlt(localctx, 1) 7692 { 7693 p.SetState(633) 7694 p.Match(ParserCREATE_) 7695 } 7696 p.SetState(635) 7697 p.GetErrorHandler().Sync(p) 7698 _la = p.GetTokenStream().LA(1) 7699 7700 if _la == ParserTEMP_ || _la == ParserTEMPORARY_ { 7701 { 7702 p.SetState(634) 7703 _la = p.GetTokenStream().LA(1) 7704 7705 if !(_la == ParserTEMP_ || _la == ParserTEMPORARY_) { 7706 p.GetErrorHandler().RecoverInline(p) 7707 } else { 7708 p.GetErrorHandler().ReportMatch(p) 7709 p.Consume() 7710 } 7711 } 7712 7713 } 7714 { 7715 p.SetState(637) 7716 p.Match(ParserTRIGGER_) 7717 } 7718 p.SetState(641) 7719 p.GetErrorHandler().Sync(p) 7720 7721 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 70, p.GetParserRuleContext()) == 1 { 7722 { 7723 p.SetState(638) 7724 p.Match(ParserIF_) 7725 } 7726 { 7727 p.SetState(639) 7728 p.Match(ParserNOT_) 7729 } 7730 { 7731 p.SetState(640) 7732 p.Match(ParserEXISTS_) 7733 } 7734 7735 } 7736 p.SetState(646) 7737 p.GetErrorHandler().Sync(p) 7738 7739 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 71, p.GetParserRuleContext()) == 1 { 7740 { 7741 p.SetState(643) 7742 p.Schema_name() 7743 } 7744 { 7745 p.SetState(644) 7746 p.Match(ParserDOT) 7747 } 7748 7749 } 7750 { 7751 p.SetState(648) 7752 p.Trigger_name() 7753 } 7754 p.SetState(653) 7755 p.GetErrorHandler().Sync(p) 7756 7757 switch p.GetTokenStream().LA(1) { 7758 case ParserBEFORE_: 7759 { 7760 p.SetState(649) 7761 p.Match(ParserBEFORE_) 7762 } 7763 7764 case ParserAFTER_: 7765 { 7766 p.SetState(650) 7767 p.Match(ParserAFTER_) 7768 } 7769 7770 case ParserINSTEAD_: 7771 { 7772 p.SetState(651) 7773 p.Match(ParserINSTEAD_) 7774 } 7775 { 7776 p.SetState(652) 7777 p.Match(ParserOF_) 7778 } 7779 7780 case ParserDELETE_, ParserINSERT_, ParserUPDATE_: 7781 7782 default: 7783 } 7784 p.SetState(669) 7785 p.GetErrorHandler().Sync(p) 7786 7787 switch p.GetTokenStream().LA(1) { 7788 case ParserDELETE_: 7789 { 7790 p.SetState(655) 7791 p.Match(ParserDELETE_) 7792 } 7793 7794 case ParserINSERT_: 7795 { 7796 p.SetState(656) 7797 p.Match(ParserINSERT_) 7798 } 7799 7800 case ParserUPDATE_: 7801 { 7802 p.SetState(657) 7803 p.Match(ParserUPDATE_) 7804 } 7805 p.SetState(667) 7806 p.GetErrorHandler().Sync(p) 7807 _la = p.GetTokenStream().LA(1) 7808 7809 if _la == ParserOF_ { 7810 { 7811 p.SetState(658) 7812 p.Match(ParserOF_) 7813 } 7814 { 7815 p.SetState(659) 7816 p.Column_name() 7817 } 7818 p.SetState(664) 7819 p.GetErrorHandler().Sync(p) 7820 _la = p.GetTokenStream().LA(1) 7821 7822 for _la == ParserCOMMA { 7823 { 7824 p.SetState(660) 7825 p.Match(ParserCOMMA) 7826 } 7827 { 7828 p.SetState(661) 7829 p.Column_name() 7830 } 7831 7832 p.SetState(666) 7833 p.GetErrorHandler().Sync(p) 7834 _la = p.GetTokenStream().LA(1) 7835 } 7836 7837 } 7838 7839 default: 7840 panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) 7841 } 7842 { 7843 p.SetState(671) 7844 p.Match(ParserON_) 7845 } 7846 { 7847 p.SetState(672) 7848 p.Table_name() 7849 } 7850 p.SetState(676) 7851 p.GetErrorHandler().Sync(p) 7852 _la = p.GetTokenStream().LA(1) 7853 7854 if _la == ParserFOR_ { 7855 { 7856 p.SetState(673) 7857 p.Match(ParserFOR_) 7858 } 7859 { 7860 p.SetState(674) 7861 p.Match(ParserEACH_) 7862 } 7863 { 7864 p.SetState(675) 7865 p.Match(ParserROW_) 7866 } 7867 7868 } 7869 p.SetState(680) 7870 p.GetErrorHandler().Sync(p) 7871 _la = p.GetTokenStream().LA(1) 7872 7873 if _la == ParserWHEN_ { 7874 { 7875 p.SetState(678) 7876 p.Match(ParserWHEN_) 7877 } 7878 { 7879 p.SetState(679) 7880 p.expr(0) 7881 } 7882 7883 } 7884 { 7885 p.SetState(682) 7886 p.Match(ParserBEGIN_) 7887 } 7888 p.SetState(691) 7889 p.GetErrorHandler().Sync(p) 7890 _la = p.GetTokenStream().LA(1) 7891 7892 for ok := true; ok; ok = _la == ParserDELETE_ || _la == ParserINSERT_ || (((_la-122)&-(0x1f+1)) == 0 && ((1<<uint((_la-122)))&((1<<(ParserREPLACE_-122))|(1<<(ParserSELECT_-122))|(1<<(ParserUPDATE_-122))|(1<<(ParserVALUES_-122))|(1<<(ParserWITH_-122)))) != 0) { 7893 p.SetState(687) 7894 p.GetErrorHandler().Sync(p) 7895 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 78, p.GetParserRuleContext()) { 7896 case 1: 7897 { 7898 p.SetState(683) 7899 p.Update_stmt() 7900 } 7901 7902 case 2: 7903 { 7904 p.SetState(684) 7905 p.Insert_stmt() 7906 } 7907 7908 case 3: 7909 { 7910 p.SetState(685) 7911 p.Delete_stmt() 7912 } 7913 7914 case 4: 7915 { 7916 p.SetState(686) 7917 p.Select_stmt() 7918 } 7919 7920 } 7921 { 7922 p.SetState(689) 7923 p.Match(ParserSCOL) 7924 } 7925 7926 p.SetState(693) 7927 p.GetErrorHandler().Sync(p) 7928 _la = p.GetTokenStream().LA(1) 7929 } 7930 { 7931 p.SetState(695) 7932 p.Match(ParserEND_) 7933 } 7934 7935 return localctx 7936 } 7937 7938 // ICreate_view_stmtContext is an interface to support dynamic dispatch. 7939 type ICreate_view_stmtContext interface { 7940 antlr.ParserRuleContext 7941 7942 // GetParser returns the parser. 7943 GetParser() antlr.Parser 7944 7945 // IsCreate_view_stmtContext differentiates from other interfaces. 7946 IsCreate_view_stmtContext() 7947 } 7948 7949 type Create_view_stmtContext struct { 7950 *antlr.BaseParserRuleContext 7951 parser antlr.Parser 7952 } 7953 7954 func NewEmptyCreate_view_stmtContext() *Create_view_stmtContext { 7955 var p = new(Create_view_stmtContext) 7956 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 7957 p.RuleIndex = ParserRULE_create_view_stmt 7958 return p 7959 } 7960 7961 func (*Create_view_stmtContext) IsCreate_view_stmtContext() {} 7962 7963 func NewCreate_view_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_view_stmtContext { 7964 var p = new(Create_view_stmtContext) 7965 7966 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 7967 7968 p.parser = parser 7969 p.RuleIndex = ParserRULE_create_view_stmt 7970 7971 return p 7972 } 7973 7974 func (s *Create_view_stmtContext) GetParser() antlr.Parser { return s.parser } 7975 7976 func (s *Create_view_stmtContext) CREATE_() antlr.TerminalNode { 7977 return s.GetToken(ParserCREATE_, 0) 7978 } 7979 7980 func (s *Create_view_stmtContext) VIEW_() antlr.TerminalNode { 7981 return s.GetToken(ParserVIEW_, 0) 7982 } 7983 7984 func (s *Create_view_stmtContext) View_name() IView_nameContext { 7985 var t antlr.RuleContext 7986 for _, ctx := range s.GetChildren() { 7987 if _, ok := ctx.(IView_nameContext); ok { 7988 t = ctx.(antlr.RuleContext) 7989 break 7990 } 7991 } 7992 7993 if t == nil { 7994 return nil 7995 } 7996 7997 return t.(IView_nameContext) 7998 } 7999 8000 func (s *Create_view_stmtContext) AS_() antlr.TerminalNode { 8001 return s.GetToken(ParserAS_, 0) 8002 } 8003 8004 func (s *Create_view_stmtContext) Select_stmt() ISelect_stmtContext { 8005 var t antlr.RuleContext 8006 for _, ctx := range s.GetChildren() { 8007 if _, ok := ctx.(ISelect_stmtContext); ok { 8008 t = ctx.(antlr.RuleContext) 8009 break 8010 } 8011 } 8012 8013 if t == nil { 8014 return nil 8015 } 8016 8017 return t.(ISelect_stmtContext) 8018 } 8019 8020 func (s *Create_view_stmtContext) IF_() antlr.TerminalNode { 8021 return s.GetToken(ParserIF_, 0) 8022 } 8023 8024 func (s *Create_view_stmtContext) NOT_() antlr.TerminalNode { 8025 return s.GetToken(ParserNOT_, 0) 8026 } 8027 8028 func (s *Create_view_stmtContext) EXISTS_() antlr.TerminalNode { 8029 return s.GetToken(ParserEXISTS_, 0) 8030 } 8031 8032 func (s *Create_view_stmtContext) Schema_name() ISchema_nameContext { 8033 var t antlr.RuleContext 8034 for _, ctx := range s.GetChildren() { 8035 if _, ok := ctx.(ISchema_nameContext); ok { 8036 t = ctx.(antlr.RuleContext) 8037 break 8038 } 8039 } 8040 8041 if t == nil { 8042 return nil 8043 } 8044 8045 return t.(ISchema_nameContext) 8046 } 8047 8048 func (s *Create_view_stmtContext) DOT() antlr.TerminalNode { 8049 return s.GetToken(ParserDOT, 0) 8050 } 8051 8052 func (s *Create_view_stmtContext) OPEN_PAR() antlr.TerminalNode { 8053 return s.GetToken(ParserOPEN_PAR, 0) 8054 } 8055 8056 func (s *Create_view_stmtContext) AllColumn_name() []IColumn_nameContext { 8057 children := s.GetChildren() 8058 len := 0 8059 for _, ctx := range children { 8060 if _, ok := ctx.(IColumn_nameContext); ok { 8061 len++ 8062 } 8063 } 8064 8065 tst := make([]IColumn_nameContext, len) 8066 i := 0 8067 for _, ctx := range children { 8068 if t, ok := ctx.(IColumn_nameContext); ok { 8069 tst[i] = t.(IColumn_nameContext) 8070 i++ 8071 } 8072 } 8073 8074 return tst 8075 } 8076 8077 func (s *Create_view_stmtContext) Column_name(i int) IColumn_nameContext { 8078 var t antlr.RuleContext 8079 j := 0 8080 for _, ctx := range s.GetChildren() { 8081 if _, ok := ctx.(IColumn_nameContext); ok { 8082 if j == i { 8083 t = ctx.(antlr.RuleContext) 8084 break 8085 } 8086 j++ 8087 } 8088 } 8089 8090 if t == nil { 8091 return nil 8092 } 8093 8094 return t.(IColumn_nameContext) 8095 } 8096 8097 func (s *Create_view_stmtContext) CLOSE_PAR() antlr.TerminalNode { 8098 return s.GetToken(ParserCLOSE_PAR, 0) 8099 } 8100 8101 func (s *Create_view_stmtContext) TEMP_() antlr.TerminalNode { 8102 return s.GetToken(ParserTEMP_, 0) 8103 } 8104 8105 func (s *Create_view_stmtContext) TEMPORARY_() antlr.TerminalNode { 8106 return s.GetToken(ParserTEMPORARY_, 0) 8107 } 8108 8109 func (s *Create_view_stmtContext) AllCOMMA() []antlr.TerminalNode { 8110 return s.GetTokens(ParserCOMMA) 8111 } 8112 8113 func (s *Create_view_stmtContext) COMMA(i int) antlr.TerminalNode { 8114 return s.GetToken(ParserCOMMA, i) 8115 } 8116 8117 func (s *Create_view_stmtContext) GetRuleContext() antlr.RuleContext { 8118 return s 8119 } 8120 8121 func (s *Create_view_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 8122 return antlr.TreesStringTree(s, ruleNames, recog) 8123 } 8124 8125 func (s *Create_view_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 8126 if listenerT, ok := listener.(ParserListener); ok { 8127 listenerT.EnterCreate_view_stmt(s) 8128 } 8129 } 8130 8131 func (s *Create_view_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 8132 if listenerT, ok := listener.(ParserListener); ok { 8133 listenerT.ExitCreate_view_stmt(s) 8134 } 8135 } 8136 8137 func (s *Create_view_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 8138 switch t := visitor.(type) { 8139 case ParserVisitor: 8140 return t.VisitCreate_view_stmt(s) 8141 8142 default: 8143 return t.VisitChildren(s) 8144 } 8145 } 8146 8147 func (p *Parser) Create_view_stmt() (localctx ICreate_view_stmtContext) { 8148 this := p 8149 _ = this 8150 8151 localctx = NewCreate_view_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 8152 p.EnterRule(localctx, 44, ParserRULE_create_view_stmt) 8153 var _la int 8154 8155 defer func() { 8156 p.ExitRule() 8157 }() 8158 8159 defer func() { 8160 if err := recover(); err != nil { 8161 if v, ok := err.(antlr.RecognitionException); ok { 8162 localctx.SetException(v) 8163 p.GetErrorHandler().ReportError(p, v) 8164 p.GetErrorHandler().Recover(p, v) 8165 } else { 8166 panic(err) 8167 } 8168 } 8169 }() 8170 8171 p.EnterOuterAlt(localctx, 1) 8172 { 8173 p.SetState(697) 8174 p.Match(ParserCREATE_) 8175 } 8176 p.SetState(699) 8177 p.GetErrorHandler().Sync(p) 8178 _la = p.GetTokenStream().LA(1) 8179 8180 if _la == ParserTEMP_ || _la == ParserTEMPORARY_ { 8181 { 8182 p.SetState(698) 8183 _la = p.GetTokenStream().LA(1) 8184 8185 if !(_la == ParserTEMP_ || _la == ParserTEMPORARY_) { 8186 p.GetErrorHandler().RecoverInline(p) 8187 } else { 8188 p.GetErrorHandler().ReportMatch(p) 8189 p.Consume() 8190 } 8191 } 8192 8193 } 8194 { 8195 p.SetState(701) 8196 p.Match(ParserVIEW_) 8197 } 8198 p.SetState(705) 8199 p.GetErrorHandler().Sync(p) 8200 8201 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 81, p.GetParserRuleContext()) == 1 { 8202 { 8203 p.SetState(702) 8204 p.Match(ParserIF_) 8205 } 8206 { 8207 p.SetState(703) 8208 p.Match(ParserNOT_) 8209 } 8210 { 8211 p.SetState(704) 8212 p.Match(ParserEXISTS_) 8213 } 8214 8215 } 8216 p.SetState(710) 8217 p.GetErrorHandler().Sync(p) 8218 8219 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 82, p.GetParserRuleContext()) == 1 { 8220 { 8221 p.SetState(707) 8222 p.Schema_name() 8223 } 8224 { 8225 p.SetState(708) 8226 p.Match(ParserDOT) 8227 } 8228 8229 } 8230 { 8231 p.SetState(712) 8232 p.View_name() 8233 } 8234 p.SetState(724) 8235 p.GetErrorHandler().Sync(p) 8236 _la = p.GetTokenStream().LA(1) 8237 8238 if _la == ParserOPEN_PAR { 8239 { 8240 p.SetState(713) 8241 p.Match(ParserOPEN_PAR) 8242 } 8243 { 8244 p.SetState(714) 8245 p.Column_name() 8246 } 8247 p.SetState(719) 8248 p.GetErrorHandler().Sync(p) 8249 _la = p.GetTokenStream().LA(1) 8250 8251 for _la == ParserCOMMA { 8252 { 8253 p.SetState(715) 8254 p.Match(ParserCOMMA) 8255 } 8256 { 8257 p.SetState(716) 8258 p.Column_name() 8259 } 8260 8261 p.SetState(721) 8262 p.GetErrorHandler().Sync(p) 8263 _la = p.GetTokenStream().LA(1) 8264 } 8265 { 8266 p.SetState(722) 8267 p.Match(ParserCLOSE_PAR) 8268 } 8269 8270 } 8271 { 8272 p.SetState(726) 8273 p.Match(ParserAS_) 8274 } 8275 { 8276 p.SetState(727) 8277 p.Select_stmt() 8278 } 8279 8280 return localctx 8281 } 8282 8283 // ICreate_virtual_table_stmtContext is an interface to support dynamic dispatch. 8284 type ICreate_virtual_table_stmtContext interface { 8285 antlr.ParserRuleContext 8286 8287 // GetParser returns the parser. 8288 GetParser() antlr.Parser 8289 8290 // IsCreate_virtual_table_stmtContext differentiates from other interfaces. 8291 IsCreate_virtual_table_stmtContext() 8292 } 8293 8294 type Create_virtual_table_stmtContext struct { 8295 *antlr.BaseParserRuleContext 8296 parser antlr.Parser 8297 } 8298 8299 func NewEmptyCreate_virtual_table_stmtContext() *Create_virtual_table_stmtContext { 8300 var p = new(Create_virtual_table_stmtContext) 8301 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 8302 p.RuleIndex = ParserRULE_create_virtual_table_stmt 8303 return p 8304 } 8305 8306 func (*Create_virtual_table_stmtContext) IsCreate_virtual_table_stmtContext() {} 8307 8308 func NewCreate_virtual_table_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_virtual_table_stmtContext { 8309 var p = new(Create_virtual_table_stmtContext) 8310 8311 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 8312 8313 p.parser = parser 8314 p.RuleIndex = ParserRULE_create_virtual_table_stmt 8315 8316 return p 8317 } 8318 8319 func (s *Create_virtual_table_stmtContext) GetParser() antlr.Parser { return s.parser } 8320 8321 func (s *Create_virtual_table_stmtContext) CREATE_() antlr.TerminalNode { 8322 return s.GetToken(ParserCREATE_, 0) 8323 } 8324 8325 func (s *Create_virtual_table_stmtContext) VIRTUAL_() antlr.TerminalNode { 8326 return s.GetToken(ParserVIRTUAL_, 0) 8327 } 8328 8329 func (s *Create_virtual_table_stmtContext) TABLE_() antlr.TerminalNode { 8330 return s.GetToken(ParserTABLE_, 0) 8331 } 8332 8333 func (s *Create_virtual_table_stmtContext) Table_name() ITable_nameContext { 8334 var t antlr.RuleContext 8335 for _, ctx := range s.GetChildren() { 8336 if _, ok := ctx.(ITable_nameContext); ok { 8337 t = ctx.(antlr.RuleContext) 8338 break 8339 } 8340 } 8341 8342 if t == nil { 8343 return nil 8344 } 8345 8346 return t.(ITable_nameContext) 8347 } 8348 8349 func (s *Create_virtual_table_stmtContext) USING_() antlr.TerminalNode { 8350 return s.GetToken(ParserUSING_, 0) 8351 } 8352 8353 func (s *Create_virtual_table_stmtContext) Module_name() IModule_nameContext { 8354 var t antlr.RuleContext 8355 for _, ctx := range s.GetChildren() { 8356 if _, ok := ctx.(IModule_nameContext); ok { 8357 t = ctx.(antlr.RuleContext) 8358 break 8359 } 8360 } 8361 8362 if t == nil { 8363 return nil 8364 } 8365 8366 return t.(IModule_nameContext) 8367 } 8368 8369 func (s *Create_virtual_table_stmtContext) IF_() antlr.TerminalNode { 8370 return s.GetToken(ParserIF_, 0) 8371 } 8372 8373 func (s *Create_virtual_table_stmtContext) NOT_() antlr.TerminalNode { 8374 return s.GetToken(ParserNOT_, 0) 8375 } 8376 8377 func (s *Create_virtual_table_stmtContext) EXISTS_() antlr.TerminalNode { 8378 return s.GetToken(ParserEXISTS_, 0) 8379 } 8380 8381 func (s *Create_virtual_table_stmtContext) Schema_name() ISchema_nameContext { 8382 var t antlr.RuleContext 8383 for _, ctx := range s.GetChildren() { 8384 if _, ok := ctx.(ISchema_nameContext); ok { 8385 t = ctx.(antlr.RuleContext) 8386 break 8387 } 8388 } 8389 8390 if t == nil { 8391 return nil 8392 } 8393 8394 return t.(ISchema_nameContext) 8395 } 8396 8397 func (s *Create_virtual_table_stmtContext) DOT() antlr.TerminalNode { 8398 return s.GetToken(ParserDOT, 0) 8399 } 8400 8401 func (s *Create_virtual_table_stmtContext) OPEN_PAR() antlr.TerminalNode { 8402 return s.GetToken(ParserOPEN_PAR, 0) 8403 } 8404 8405 func (s *Create_virtual_table_stmtContext) AllModule_argument() []IModule_argumentContext { 8406 children := s.GetChildren() 8407 len := 0 8408 for _, ctx := range children { 8409 if _, ok := ctx.(IModule_argumentContext); ok { 8410 len++ 8411 } 8412 } 8413 8414 tst := make([]IModule_argumentContext, len) 8415 i := 0 8416 for _, ctx := range children { 8417 if t, ok := ctx.(IModule_argumentContext); ok { 8418 tst[i] = t.(IModule_argumentContext) 8419 i++ 8420 } 8421 } 8422 8423 return tst 8424 } 8425 8426 func (s *Create_virtual_table_stmtContext) Module_argument(i int) IModule_argumentContext { 8427 var t antlr.RuleContext 8428 j := 0 8429 for _, ctx := range s.GetChildren() { 8430 if _, ok := ctx.(IModule_argumentContext); ok { 8431 if j == i { 8432 t = ctx.(antlr.RuleContext) 8433 break 8434 } 8435 j++ 8436 } 8437 } 8438 8439 if t == nil { 8440 return nil 8441 } 8442 8443 return t.(IModule_argumentContext) 8444 } 8445 8446 func (s *Create_virtual_table_stmtContext) CLOSE_PAR() antlr.TerminalNode { 8447 return s.GetToken(ParserCLOSE_PAR, 0) 8448 } 8449 8450 func (s *Create_virtual_table_stmtContext) AllCOMMA() []antlr.TerminalNode { 8451 return s.GetTokens(ParserCOMMA) 8452 } 8453 8454 func (s *Create_virtual_table_stmtContext) COMMA(i int) antlr.TerminalNode { 8455 return s.GetToken(ParserCOMMA, i) 8456 } 8457 8458 func (s *Create_virtual_table_stmtContext) GetRuleContext() antlr.RuleContext { 8459 return s 8460 } 8461 8462 func (s *Create_virtual_table_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 8463 return antlr.TreesStringTree(s, ruleNames, recog) 8464 } 8465 8466 func (s *Create_virtual_table_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 8467 if listenerT, ok := listener.(ParserListener); ok { 8468 listenerT.EnterCreate_virtual_table_stmt(s) 8469 } 8470 } 8471 8472 func (s *Create_virtual_table_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 8473 if listenerT, ok := listener.(ParserListener); ok { 8474 listenerT.ExitCreate_virtual_table_stmt(s) 8475 } 8476 } 8477 8478 func (s *Create_virtual_table_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 8479 switch t := visitor.(type) { 8480 case ParserVisitor: 8481 return t.VisitCreate_virtual_table_stmt(s) 8482 8483 default: 8484 return t.VisitChildren(s) 8485 } 8486 } 8487 8488 func (p *Parser) Create_virtual_table_stmt() (localctx ICreate_virtual_table_stmtContext) { 8489 this := p 8490 _ = this 8491 8492 localctx = NewCreate_virtual_table_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 8493 p.EnterRule(localctx, 46, ParserRULE_create_virtual_table_stmt) 8494 var _la int 8495 8496 defer func() { 8497 p.ExitRule() 8498 }() 8499 8500 defer func() { 8501 if err := recover(); err != nil { 8502 if v, ok := err.(antlr.RecognitionException); ok { 8503 localctx.SetException(v) 8504 p.GetErrorHandler().ReportError(p, v) 8505 p.GetErrorHandler().Recover(p, v) 8506 } else { 8507 panic(err) 8508 } 8509 } 8510 }() 8511 8512 p.EnterOuterAlt(localctx, 1) 8513 { 8514 p.SetState(729) 8515 p.Match(ParserCREATE_) 8516 } 8517 { 8518 p.SetState(730) 8519 p.Match(ParserVIRTUAL_) 8520 } 8521 { 8522 p.SetState(731) 8523 p.Match(ParserTABLE_) 8524 } 8525 p.SetState(735) 8526 p.GetErrorHandler().Sync(p) 8527 8528 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 85, p.GetParserRuleContext()) == 1 { 8529 { 8530 p.SetState(732) 8531 p.Match(ParserIF_) 8532 } 8533 { 8534 p.SetState(733) 8535 p.Match(ParserNOT_) 8536 } 8537 { 8538 p.SetState(734) 8539 p.Match(ParserEXISTS_) 8540 } 8541 8542 } 8543 p.SetState(740) 8544 p.GetErrorHandler().Sync(p) 8545 8546 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 86, p.GetParserRuleContext()) == 1 { 8547 { 8548 p.SetState(737) 8549 p.Schema_name() 8550 } 8551 { 8552 p.SetState(738) 8553 p.Match(ParserDOT) 8554 } 8555 8556 } 8557 { 8558 p.SetState(742) 8559 p.Table_name() 8560 } 8561 { 8562 p.SetState(743) 8563 p.Match(ParserUSING_) 8564 } 8565 { 8566 p.SetState(744) 8567 p.Module_name() 8568 } 8569 p.SetState(756) 8570 p.GetErrorHandler().Sync(p) 8571 _la = p.GetTokenStream().LA(1) 8572 8573 if _la == ParserOPEN_PAR { 8574 { 8575 p.SetState(745) 8576 p.Match(ParserOPEN_PAR) 8577 } 8578 { 8579 p.SetState(746) 8580 p.Module_argument() 8581 } 8582 p.SetState(751) 8583 p.GetErrorHandler().Sync(p) 8584 _la = p.GetTokenStream().LA(1) 8585 8586 for _la == ParserCOMMA { 8587 { 8588 p.SetState(747) 8589 p.Match(ParserCOMMA) 8590 } 8591 { 8592 p.SetState(748) 8593 p.Module_argument() 8594 } 8595 8596 p.SetState(753) 8597 p.GetErrorHandler().Sync(p) 8598 _la = p.GetTokenStream().LA(1) 8599 } 8600 { 8601 p.SetState(754) 8602 p.Match(ParserCLOSE_PAR) 8603 } 8604 8605 } 8606 8607 return localctx 8608 } 8609 8610 // IWith_clauseContext is an interface to support dynamic dispatch. 8611 type IWith_clauseContext interface { 8612 antlr.ParserRuleContext 8613 8614 // GetParser returns the parser. 8615 GetParser() antlr.Parser 8616 8617 // IsWith_clauseContext differentiates from other interfaces. 8618 IsWith_clauseContext() 8619 } 8620 8621 type With_clauseContext struct { 8622 *antlr.BaseParserRuleContext 8623 parser antlr.Parser 8624 } 8625 8626 func NewEmptyWith_clauseContext() *With_clauseContext { 8627 var p = new(With_clauseContext) 8628 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 8629 p.RuleIndex = ParserRULE_with_clause 8630 return p 8631 } 8632 8633 func (*With_clauseContext) IsWith_clauseContext() {} 8634 8635 func NewWith_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_clauseContext { 8636 var p = new(With_clauseContext) 8637 8638 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 8639 8640 p.parser = parser 8641 p.RuleIndex = ParserRULE_with_clause 8642 8643 return p 8644 } 8645 8646 func (s *With_clauseContext) GetParser() antlr.Parser { return s.parser } 8647 8648 func (s *With_clauseContext) WITH_() antlr.TerminalNode { 8649 return s.GetToken(ParserWITH_, 0) 8650 } 8651 8652 func (s *With_clauseContext) AllCte_table_name() []ICte_table_nameContext { 8653 children := s.GetChildren() 8654 len := 0 8655 for _, ctx := range children { 8656 if _, ok := ctx.(ICte_table_nameContext); ok { 8657 len++ 8658 } 8659 } 8660 8661 tst := make([]ICte_table_nameContext, len) 8662 i := 0 8663 for _, ctx := range children { 8664 if t, ok := ctx.(ICte_table_nameContext); ok { 8665 tst[i] = t.(ICte_table_nameContext) 8666 i++ 8667 } 8668 } 8669 8670 return tst 8671 } 8672 8673 func (s *With_clauseContext) Cte_table_name(i int) ICte_table_nameContext { 8674 var t antlr.RuleContext 8675 j := 0 8676 for _, ctx := range s.GetChildren() { 8677 if _, ok := ctx.(ICte_table_nameContext); ok { 8678 if j == i { 8679 t = ctx.(antlr.RuleContext) 8680 break 8681 } 8682 j++ 8683 } 8684 } 8685 8686 if t == nil { 8687 return nil 8688 } 8689 8690 return t.(ICte_table_nameContext) 8691 } 8692 8693 func (s *With_clauseContext) AllAS_() []antlr.TerminalNode { 8694 return s.GetTokens(ParserAS_) 8695 } 8696 8697 func (s *With_clauseContext) AS_(i int) antlr.TerminalNode { 8698 return s.GetToken(ParserAS_, i) 8699 } 8700 8701 func (s *With_clauseContext) AllOPEN_PAR() []antlr.TerminalNode { 8702 return s.GetTokens(ParserOPEN_PAR) 8703 } 8704 8705 func (s *With_clauseContext) OPEN_PAR(i int) antlr.TerminalNode { 8706 return s.GetToken(ParserOPEN_PAR, i) 8707 } 8708 8709 func (s *With_clauseContext) AllSelect_stmt() []ISelect_stmtContext { 8710 children := s.GetChildren() 8711 len := 0 8712 for _, ctx := range children { 8713 if _, ok := ctx.(ISelect_stmtContext); ok { 8714 len++ 8715 } 8716 } 8717 8718 tst := make([]ISelect_stmtContext, len) 8719 i := 0 8720 for _, ctx := range children { 8721 if t, ok := ctx.(ISelect_stmtContext); ok { 8722 tst[i] = t.(ISelect_stmtContext) 8723 i++ 8724 } 8725 } 8726 8727 return tst 8728 } 8729 8730 func (s *With_clauseContext) Select_stmt(i int) ISelect_stmtContext { 8731 var t antlr.RuleContext 8732 j := 0 8733 for _, ctx := range s.GetChildren() { 8734 if _, ok := ctx.(ISelect_stmtContext); ok { 8735 if j == i { 8736 t = ctx.(antlr.RuleContext) 8737 break 8738 } 8739 j++ 8740 } 8741 } 8742 8743 if t == nil { 8744 return nil 8745 } 8746 8747 return t.(ISelect_stmtContext) 8748 } 8749 8750 func (s *With_clauseContext) AllCLOSE_PAR() []antlr.TerminalNode { 8751 return s.GetTokens(ParserCLOSE_PAR) 8752 } 8753 8754 func (s *With_clauseContext) CLOSE_PAR(i int) antlr.TerminalNode { 8755 return s.GetToken(ParserCLOSE_PAR, i) 8756 } 8757 8758 func (s *With_clauseContext) RECURSIVE_() antlr.TerminalNode { 8759 return s.GetToken(ParserRECURSIVE_, 0) 8760 } 8761 8762 func (s *With_clauseContext) AllCOMMA() []antlr.TerminalNode { 8763 return s.GetTokens(ParserCOMMA) 8764 } 8765 8766 func (s *With_clauseContext) COMMA(i int) antlr.TerminalNode { 8767 return s.GetToken(ParserCOMMA, i) 8768 } 8769 8770 func (s *With_clauseContext) GetRuleContext() antlr.RuleContext { 8771 return s 8772 } 8773 8774 func (s *With_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 8775 return antlr.TreesStringTree(s, ruleNames, recog) 8776 } 8777 8778 func (s *With_clauseContext) EnterRule(listener antlr.ParseTreeListener) { 8779 if listenerT, ok := listener.(ParserListener); ok { 8780 listenerT.EnterWith_clause(s) 8781 } 8782 } 8783 8784 func (s *With_clauseContext) ExitRule(listener antlr.ParseTreeListener) { 8785 if listenerT, ok := listener.(ParserListener); ok { 8786 listenerT.ExitWith_clause(s) 8787 } 8788 } 8789 8790 func (s *With_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 8791 switch t := visitor.(type) { 8792 case ParserVisitor: 8793 return t.VisitWith_clause(s) 8794 8795 default: 8796 return t.VisitChildren(s) 8797 } 8798 } 8799 8800 func (p *Parser) With_clause() (localctx IWith_clauseContext) { 8801 this := p 8802 _ = this 8803 8804 localctx = NewWith_clauseContext(p, p.GetParserRuleContext(), p.GetState()) 8805 p.EnterRule(localctx, 48, ParserRULE_with_clause) 8806 var _la int 8807 8808 defer func() { 8809 p.ExitRule() 8810 }() 8811 8812 defer func() { 8813 if err := recover(); err != nil { 8814 if v, ok := err.(antlr.RecognitionException); ok { 8815 localctx.SetException(v) 8816 p.GetErrorHandler().ReportError(p, v) 8817 p.GetErrorHandler().Recover(p, v) 8818 } else { 8819 panic(err) 8820 } 8821 } 8822 }() 8823 8824 p.EnterOuterAlt(localctx, 1) 8825 { 8826 p.SetState(758) 8827 p.Match(ParserWITH_) 8828 } 8829 p.SetState(760) 8830 p.GetErrorHandler().Sync(p) 8831 8832 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 89, p.GetParserRuleContext()) == 1 { 8833 { 8834 p.SetState(759) 8835 p.Match(ParserRECURSIVE_) 8836 } 8837 8838 } 8839 { 8840 p.SetState(762) 8841 p.Cte_table_name() 8842 } 8843 { 8844 p.SetState(763) 8845 p.Match(ParserAS_) 8846 } 8847 { 8848 p.SetState(764) 8849 p.Match(ParserOPEN_PAR) 8850 } 8851 { 8852 p.SetState(765) 8853 p.Select_stmt() 8854 } 8855 { 8856 p.SetState(766) 8857 p.Match(ParserCLOSE_PAR) 8858 } 8859 p.SetState(776) 8860 p.GetErrorHandler().Sync(p) 8861 _la = p.GetTokenStream().LA(1) 8862 8863 for _la == ParserCOMMA { 8864 { 8865 p.SetState(767) 8866 p.Match(ParserCOMMA) 8867 } 8868 { 8869 p.SetState(768) 8870 p.Cte_table_name() 8871 } 8872 { 8873 p.SetState(769) 8874 p.Match(ParserAS_) 8875 } 8876 { 8877 p.SetState(770) 8878 p.Match(ParserOPEN_PAR) 8879 } 8880 { 8881 p.SetState(771) 8882 p.Select_stmt() 8883 } 8884 { 8885 p.SetState(772) 8886 p.Match(ParserCLOSE_PAR) 8887 } 8888 8889 p.SetState(778) 8890 p.GetErrorHandler().Sync(p) 8891 _la = p.GetTokenStream().LA(1) 8892 } 8893 8894 return localctx 8895 } 8896 8897 // ICte_table_nameContext is an interface to support dynamic dispatch. 8898 type ICte_table_nameContext interface { 8899 antlr.ParserRuleContext 8900 8901 // GetParser returns the parser. 8902 GetParser() antlr.Parser 8903 8904 // IsCte_table_nameContext differentiates from other interfaces. 8905 IsCte_table_nameContext() 8906 } 8907 8908 type Cte_table_nameContext struct { 8909 *antlr.BaseParserRuleContext 8910 parser antlr.Parser 8911 } 8912 8913 func NewEmptyCte_table_nameContext() *Cte_table_nameContext { 8914 var p = new(Cte_table_nameContext) 8915 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 8916 p.RuleIndex = ParserRULE_cte_table_name 8917 return p 8918 } 8919 8920 func (*Cte_table_nameContext) IsCte_table_nameContext() {} 8921 8922 func NewCte_table_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cte_table_nameContext { 8923 var p = new(Cte_table_nameContext) 8924 8925 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 8926 8927 p.parser = parser 8928 p.RuleIndex = ParserRULE_cte_table_name 8929 8930 return p 8931 } 8932 8933 func (s *Cte_table_nameContext) GetParser() antlr.Parser { return s.parser } 8934 8935 func (s *Cte_table_nameContext) Table_name() ITable_nameContext { 8936 var t antlr.RuleContext 8937 for _, ctx := range s.GetChildren() { 8938 if _, ok := ctx.(ITable_nameContext); ok { 8939 t = ctx.(antlr.RuleContext) 8940 break 8941 } 8942 } 8943 8944 if t == nil { 8945 return nil 8946 } 8947 8948 return t.(ITable_nameContext) 8949 } 8950 8951 func (s *Cte_table_nameContext) OPEN_PAR() antlr.TerminalNode { 8952 return s.GetToken(ParserOPEN_PAR, 0) 8953 } 8954 8955 func (s *Cte_table_nameContext) AllColumn_name() []IColumn_nameContext { 8956 children := s.GetChildren() 8957 len := 0 8958 for _, ctx := range children { 8959 if _, ok := ctx.(IColumn_nameContext); ok { 8960 len++ 8961 } 8962 } 8963 8964 tst := make([]IColumn_nameContext, len) 8965 i := 0 8966 for _, ctx := range children { 8967 if t, ok := ctx.(IColumn_nameContext); ok { 8968 tst[i] = t.(IColumn_nameContext) 8969 i++ 8970 } 8971 } 8972 8973 return tst 8974 } 8975 8976 func (s *Cte_table_nameContext) Column_name(i int) IColumn_nameContext { 8977 var t antlr.RuleContext 8978 j := 0 8979 for _, ctx := range s.GetChildren() { 8980 if _, ok := ctx.(IColumn_nameContext); ok { 8981 if j == i { 8982 t = ctx.(antlr.RuleContext) 8983 break 8984 } 8985 j++ 8986 } 8987 } 8988 8989 if t == nil { 8990 return nil 8991 } 8992 8993 return t.(IColumn_nameContext) 8994 } 8995 8996 func (s *Cte_table_nameContext) CLOSE_PAR() antlr.TerminalNode { 8997 return s.GetToken(ParserCLOSE_PAR, 0) 8998 } 8999 9000 func (s *Cte_table_nameContext) AllCOMMA() []antlr.TerminalNode { 9001 return s.GetTokens(ParserCOMMA) 9002 } 9003 9004 func (s *Cte_table_nameContext) COMMA(i int) antlr.TerminalNode { 9005 return s.GetToken(ParserCOMMA, i) 9006 } 9007 9008 func (s *Cte_table_nameContext) GetRuleContext() antlr.RuleContext { 9009 return s 9010 } 9011 9012 func (s *Cte_table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 9013 return antlr.TreesStringTree(s, ruleNames, recog) 9014 } 9015 9016 func (s *Cte_table_nameContext) EnterRule(listener antlr.ParseTreeListener) { 9017 if listenerT, ok := listener.(ParserListener); ok { 9018 listenerT.EnterCte_table_name(s) 9019 } 9020 } 9021 9022 func (s *Cte_table_nameContext) ExitRule(listener antlr.ParseTreeListener) { 9023 if listenerT, ok := listener.(ParserListener); ok { 9024 listenerT.ExitCte_table_name(s) 9025 } 9026 } 9027 9028 func (s *Cte_table_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 9029 switch t := visitor.(type) { 9030 case ParserVisitor: 9031 return t.VisitCte_table_name(s) 9032 9033 default: 9034 return t.VisitChildren(s) 9035 } 9036 } 9037 9038 func (p *Parser) Cte_table_name() (localctx ICte_table_nameContext) { 9039 this := p 9040 _ = this 9041 9042 localctx = NewCte_table_nameContext(p, p.GetParserRuleContext(), p.GetState()) 9043 p.EnterRule(localctx, 50, ParserRULE_cte_table_name) 9044 var _la int 9045 9046 defer func() { 9047 p.ExitRule() 9048 }() 9049 9050 defer func() { 9051 if err := recover(); err != nil { 9052 if v, ok := err.(antlr.RecognitionException); ok { 9053 localctx.SetException(v) 9054 p.GetErrorHandler().ReportError(p, v) 9055 p.GetErrorHandler().Recover(p, v) 9056 } else { 9057 panic(err) 9058 } 9059 } 9060 }() 9061 9062 p.EnterOuterAlt(localctx, 1) 9063 { 9064 p.SetState(779) 9065 p.Table_name() 9066 } 9067 p.SetState(791) 9068 p.GetErrorHandler().Sync(p) 9069 _la = p.GetTokenStream().LA(1) 9070 9071 if _la == ParserOPEN_PAR { 9072 { 9073 p.SetState(780) 9074 p.Match(ParserOPEN_PAR) 9075 } 9076 { 9077 p.SetState(781) 9078 p.Column_name() 9079 } 9080 p.SetState(786) 9081 p.GetErrorHandler().Sync(p) 9082 _la = p.GetTokenStream().LA(1) 9083 9084 for _la == ParserCOMMA { 9085 { 9086 p.SetState(782) 9087 p.Match(ParserCOMMA) 9088 } 9089 { 9090 p.SetState(783) 9091 p.Column_name() 9092 } 9093 9094 p.SetState(788) 9095 p.GetErrorHandler().Sync(p) 9096 _la = p.GetTokenStream().LA(1) 9097 } 9098 { 9099 p.SetState(789) 9100 p.Match(ParserCLOSE_PAR) 9101 } 9102 9103 } 9104 9105 return localctx 9106 } 9107 9108 // IRecursive_cteContext is an interface to support dynamic dispatch. 9109 type IRecursive_cteContext interface { 9110 antlr.ParserRuleContext 9111 9112 // GetParser returns the parser. 9113 GetParser() antlr.Parser 9114 9115 // IsRecursive_cteContext differentiates from other interfaces. 9116 IsRecursive_cteContext() 9117 } 9118 9119 type Recursive_cteContext struct { 9120 *antlr.BaseParserRuleContext 9121 parser antlr.Parser 9122 } 9123 9124 func NewEmptyRecursive_cteContext() *Recursive_cteContext { 9125 var p = new(Recursive_cteContext) 9126 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 9127 p.RuleIndex = ParserRULE_recursive_cte 9128 return p 9129 } 9130 9131 func (*Recursive_cteContext) IsRecursive_cteContext() {} 9132 9133 func NewRecursive_cteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Recursive_cteContext { 9134 var p = new(Recursive_cteContext) 9135 9136 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 9137 9138 p.parser = parser 9139 p.RuleIndex = ParserRULE_recursive_cte 9140 9141 return p 9142 } 9143 9144 func (s *Recursive_cteContext) GetParser() antlr.Parser { return s.parser } 9145 9146 func (s *Recursive_cteContext) Cte_table_name() ICte_table_nameContext { 9147 var t antlr.RuleContext 9148 for _, ctx := range s.GetChildren() { 9149 if _, ok := ctx.(ICte_table_nameContext); ok { 9150 t = ctx.(antlr.RuleContext) 9151 break 9152 } 9153 } 9154 9155 if t == nil { 9156 return nil 9157 } 9158 9159 return t.(ICte_table_nameContext) 9160 } 9161 9162 func (s *Recursive_cteContext) AS_() antlr.TerminalNode { 9163 return s.GetToken(ParserAS_, 0) 9164 } 9165 9166 func (s *Recursive_cteContext) OPEN_PAR() antlr.TerminalNode { 9167 return s.GetToken(ParserOPEN_PAR, 0) 9168 } 9169 9170 func (s *Recursive_cteContext) Initial_select() IInitial_selectContext { 9171 var t antlr.RuleContext 9172 for _, ctx := range s.GetChildren() { 9173 if _, ok := ctx.(IInitial_selectContext); ok { 9174 t = ctx.(antlr.RuleContext) 9175 break 9176 } 9177 } 9178 9179 if t == nil { 9180 return nil 9181 } 9182 9183 return t.(IInitial_selectContext) 9184 } 9185 9186 func (s *Recursive_cteContext) UNION_() antlr.TerminalNode { 9187 return s.GetToken(ParserUNION_, 0) 9188 } 9189 9190 func (s *Recursive_cteContext) Recursive_select() IRecursive_selectContext { 9191 var t antlr.RuleContext 9192 for _, ctx := range s.GetChildren() { 9193 if _, ok := ctx.(IRecursive_selectContext); ok { 9194 t = ctx.(antlr.RuleContext) 9195 break 9196 } 9197 } 9198 9199 if t == nil { 9200 return nil 9201 } 9202 9203 return t.(IRecursive_selectContext) 9204 } 9205 9206 func (s *Recursive_cteContext) CLOSE_PAR() antlr.TerminalNode { 9207 return s.GetToken(ParserCLOSE_PAR, 0) 9208 } 9209 9210 func (s *Recursive_cteContext) ALL_() antlr.TerminalNode { 9211 return s.GetToken(ParserALL_, 0) 9212 } 9213 9214 func (s *Recursive_cteContext) GetRuleContext() antlr.RuleContext { 9215 return s 9216 } 9217 9218 func (s *Recursive_cteContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 9219 return antlr.TreesStringTree(s, ruleNames, recog) 9220 } 9221 9222 func (s *Recursive_cteContext) EnterRule(listener antlr.ParseTreeListener) { 9223 if listenerT, ok := listener.(ParserListener); ok { 9224 listenerT.EnterRecursive_cte(s) 9225 } 9226 } 9227 9228 func (s *Recursive_cteContext) ExitRule(listener antlr.ParseTreeListener) { 9229 if listenerT, ok := listener.(ParserListener); ok { 9230 listenerT.ExitRecursive_cte(s) 9231 } 9232 } 9233 9234 func (s *Recursive_cteContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 9235 switch t := visitor.(type) { 9236 case ParserVisitor: 9237 return t.VisitRecursive_cte(s) 9238 9239 default: 9240 return t.VisitChildren(s) 9241 } 9242 } 9243 9244 func (p *Parser) Recursive_cte() (localctx IRecursive_cteContext) { 9245 this := p 9246 _ = this 9247 9248 localctx = NewRecursive_cteContext(p, p.GetParserRuleContext(), p.GetState()) 9249 p.EnterRule(localctx, 52, ParserRULE_recursive_cte) 9250 var _la int 9251 9252 defer func() { 9253 p.ExitRule() 9254 }() 9255 9256 defer func() { 9257 if err := recover(); err != nil { 9258 if v, ok := err.(antlr.RecognitionException); ok { 9259 localctx.SetException(v) 9260 p.GetErrorHandler().ReportError(p, v) 9261 p.GetErrorHandler().Recover(p, v) 9262 } else { 9263 panic(err) 9264 } 9265 } 9266 }() 9267 9268 p.EnterOuterAlt(localctx, 1) 9269 { 9270 p.SetState(793) 9271 p.Cte_table_name() 9272 } 9273 { 9274 p.SetState(794) 9275 p.Match(ParserAS_) 9276 } 9277 { 9278 p.SetState(795) 9279 p.Match(ParserOPEN_PAR) 9280 } 9281 { 9282 p.SetState(796) 9283 p.Initial_select() 9284 } 9285 { 9286 p.SetState(797) 9287 p.Match(ParserUNION_) 9288 } 9289 p.SetState(799) 9290 p.GetErrorHandler().Sync(p) 9291 _la = p.GetTokenStream().LA(1) 9292 9293 if _la == ParserALL_ { 9294 { 9295 p.SetState(798) 9296 p.Match(ParserALL_) 9297 } 9298 9299 } 9300 { 9301 p.SetState(801) 9302 p.Recursive_select() 9303 } 9304 { 9305 p.SetState(802) 9306 p.Match(ParserCLOSE_PAR) 9307 } 9308 9309 return localctx 9310 } 9311 9312 // ICommon_table_expressionContext is an interface to support dynamic dispatch. 9313 type ICommon_table_expressionContext interface { 9314 antlr.ParserRuleContext 9315 9316 // GetParser returns the parser. 9317 GetParser() antlr.Parser 9318 9319 // IsCommon_table_expressionContext differentiates from other interfaces. 9320 IsCommon_table_expressionContext() 9321 } 9322 9323 type Common_table_expressionContext struct { 9324 *antlr.BaseParserRuleContext 9325 parser antlr.Parser 9326 } 9327 9328 func NewEmptyCommon_table_expressionContext() *Common_table_expressionContext { 9329 var p = new(Common_table_expressionContext) 9330 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 9331 p.RuleIndex = ParserRULE_common_table_expression 9332 return p 9333 } 9334 9335 func (*Common_table_expressionContext) IsCommon_table_expressionContext() {} 9336 9337 func NewCommon_table_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Common_table_expressionContext { 9338 var p = new(Common_table_expressionContext) 9339 9340 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 9341 9342 p.parser = parser 9343 p.RuleIndex = ParserRULE_common_table_expression 9344 9345 return p 9346 } 9347 9348 func (s *Common_table_expressionContext) GetParser() antlr.Parser { return s.parser } 9349 9350 func (s *Common_table_expressionContext) Table_name() ITable_nameContext { 9351 var t antlr.RuleContext 9352 for _, ctx := range s.GetChildren() { 9353 if _, ok := ctx.(ITable_nameContext); ok { 9354 t = ctx.(antlr.RuleContext) 9355 break 9356 } 9357 } 9358 9359 if t == nil { 9360 return nil 9361 } 9362 9363 return t.(ITable_nameContext) 9364 } 9365 9366 func (s *Common_table_expressionContext) AS_() antlr.TerminalNode { 9367 return s.GetToken(ParserAS_, 0) 9368 } 9369 9370 func (s *Common_table_expressionContext) AllOPEN_PAR() []antlr.TerminalNode { 9371 return s.GetTokens(ParserOPEN_PAR) 9372 } 9373 9374 func (s *Common_table_expressionContext) OPEN_PAR(i int) antlr.TerminalNode { 9375 return s.GetToken(ParserOPEN_PAR, i) 9376 } 9377 9378 func (s *Common_table_expressionContext) Select_stmt() ISelect_stmtContext { 9379 var t antlr.RuleContext 9380 for _, ctx := range s.GetChildren() { 9381 if _, ok := ctx.(ISelect_stmtContext); ok { 9382 t = ctx.(antlr.RuleContext) 9383 break 9384 } 9385 } 9386 9387 if t == nil { 9388 return nil 9389 } 9390 9391 return t.(ISelect_stmtContext) 9392 } 9393 9394 func (s *Common_table_expressionContext) AllCLOSE_PAR() []antlr.TerminalNode { 9395 return s.GetTokens(ParserCLOSE_PAR) 9396 } 9397 9398 func (s *Common_table_expressionContext) CLOSE_PAR(i int) antlr.TerminalNode { 9399 return s.GetToken(ParserCLOSE_PAR, i) 9400 } 9401 9402 func (s *Common_table_expressionContext) AllColumn_name() []IColumn_nameContext { 9403 children := s.GetChildren() 9404 len := 0 9405 for _, ctx := range children { 9406 if _, ok := ctx.(IColumn_nameContext); ok { 9407 len++ 9408 } 9409 } 9410 9411 tst := make([]IColumn_nameContext, len) 9412 i := 0 9413 for _, ctx := range children { 9414 if t, ok := ctx.(IColumn_nameContext); ok { 9415 tst[i] = t.(IColumn_nameContext) 9416 i++ 9417 } 9418 } 9419 9420 return tst 9421 } 9422 9423 func (s *Common_table_expressionContext) Column_name(i int) IColumn_nameContext { 9424 var t antlr.RuleContext 9425 j := 0 9426 for _, ctx := range s.GetChildren() { 9427 if _, ok := ctx.(IColumn_nameContext); ok { 9428 if j == i { 9429 t = ctx.(antlr.RuleContext) 9430 break 9431 } 9432 j++ 9433 } 9434 } 9435 9436 if t == nil { 9437 return nil 9438 } 9439 9440 return t.(IColumn_nameContext) 9441 } 9442 9443 func (s *Common_table_expressionContext) AllCOMMA() []antlr.TerminalNode { 9444 return s.GetTokens(ParserCOMMA) 9445 } 9446 9447 func (s *Common_table_expressionContext) COMMA(i int) antlr.TerminalNode { 9448 return s.GetToken(ParserCOMMA, i) 9449 } 9450 9451 func (s *Common_table_expressionContext) GetRuleContext() antlr.RuleContext { 9452 return s 9453 } 9454 9455 func (s *Common_table_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 9456 return antlr.TreesStringTree(s, ruleNames, recog) 9457 } 9458 9459 func (s *Common_table_expressionContext) EnterRule(listener antlr.ParseTreeListener) { 9460 if listenerT, ok := listener.(ParserListener); ok { 9461 listenerT.EnterCommon_table_expression(s) 9462 } 9463 } 9464 9465 func (s *Common_table_expressionContext) ExitRule(listener antlr.ParseTreeListener) { 9466 if listenerT, ok := listener.(ParserListener); ok { 9467 listenerT.ExitCommon_table_expression(s) 9468 } 9469 } 9470 9471 func (s *Common_table_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 9472 switch t := visitor.(type) { 9473 case ParserVisitor: 9474 return t.VisitCommon_table_expression(s) 9475 9476 default: 9477 return t.VisitChildren(s) 9478 } 9479 } 9480 9481 func (p *Parser) Common_table_expression() (localctx ICommon_table_expressionContext) { 9482 this := p 9483 _ = this 9484 9485 localctx = NewCommon_table_expressionContext(p, p.GetParserRuleContext(), p.GetState()) 9486 p.EnterRule(localctx, 54, ParserRULE_common_table_expression) 9487 var _la int 9488 9489 defer func() { 9490 p.ExitRule() 9491 }() 9492 9493 defer func() { 9494 if err := recover(); err != nil { 9495 if v, ok := err.(antlr.RecognitionException); ok { 9496 localctx.SetException(v) 9497 p.GetErrorHandler().ReportError(p, v) 9498 p.GetErrorHandler().Recover(p, v) 9499 } else { 9500 panic(err) 9501 } 9502 } 9503 }() 9504 9505 p.EnterOuterAlt(localctx, 1) 9506 { 9507 p.SetState(804) 9508 p.Table_name() 9509 } 9510 p.SetState(816) 9511 p.GetErrorHandler().Sync(p) 9512 _la = p.GetTokenStream().LA(1) 9513 9514 if _la == ParserOPEN_PAR { 9515 { 9516 p.SetState(805) 9517 p.Match(ParserOPEN_PAR) 9518 } 9519 { 9520 p.SetState(806) 9521 p.Column_name() 9522 } 9523 p.SetState(811) 9524 p.GetErrorHandler().Sync(p) 9525 _la = p.GetTokenStream().LA(1) 9526 9527 for _la == ParserCOMMA { 9528 { 9529 p.SetState(807) 9530 p.Match(ParserCOMMA) 9531 } 9532 { 9533 p.SetState(808) 9534 p.Column_name() 9535 } 9536 9537 p.SetState(813) 9538 p.GetErrorHandler().Sync(p) 9539 _la = p.GetTokenStream().LA(1) 9540 } 9541 { 9542 p.SetState(814) 9543 p.Match(ParserCLOSE_PAR) 9544 } 9545 9546 } 9547 { 9548 p.SetState(818) 9549 p.Match(ParserAS_) 9550 } 9551 { 9552 p.SetState(819) 9553 p.Match(ParserOPEN_PAR) 9554 } 9555 { 9556 p.SetState(820) 9557 p.Select_stmt() 9558 } 9559 { 9560 p.SetState(821) 9561 p.Match(ParserCLOSE_PAR) 9562 } 9563 9564 return localctx 9565 } 9566 9567 // IDelete_stmtContext is an interface to support dynamic dispatch. 9568 type IDelete_stmtContext interface { 9569 antlr.ParserRuleContext 9570 9571 // GetParser returns the parser. 9572 GetParser() antlr.Parser 9573 9574 // IsDelete_stmtContext differentiates from other interfaces. 9575 IsDelete_stmtContext() 9576 } 9577 9578 type Delete_stmtContext struct { 9579 *antlr.BaseParserRuleContext 9580 parser antlr.Parser 9581 } 9582 9583 func NewEmptyDelete_stmtContext() *Delete_stmtContext { 9584 var p = new(Delete_stmtContext) 9585 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 9586 p.RuleIndex = ParserRULE_delete_stmt 9587 return p 9588 } 9589 9590 func (*Delete_stmtContext) IsDelete_stmtContext() {} 9591 9592 func NewDelete_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Delete_stmtContext { 9593 var p = new(Delete_stmtContext) 9594 9595 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 9596 9597 p.parser = parser 9598 p.RuleIndex = ParserRULE_delete_stmt 9599 9600 return p 9601 } 9602 9603 func (s *Delete_stmtContext) GetParser() antlr.Parser { return s.parser } 9604 9605 func (s *Delete_stmtContext) DELETE_() antlr.TerminalNode { 9606 return s.GetToken(ParserDELETE_, 0) 9607 } 9608 9609 func (s *Delete_stmtContext) FROM_() antlr.TerminalNode { 9610 return s.GetToken(ParserFROM_, 0) 9611 } 9612 9613 func (s *Delete_stmtContext) Qualified_table_name() IQualified_table_nameContext { 9614 var t antlr.RuleContext 9615 for _, ctx := range s.GetChildren() { 9616 if _, ok := ctx.(IQualified_table_nameContext); ok { 9617 t = ctx.(antlr.RuleContext) 9618 break 9619 } 9620 } 9621 9622 if t == nil { 9623 return nil 9624 } 9625 9626 return t.(IQualified_table_nameContext) 9627 } 9628 9629 func (s *Delete_stmtContext) With_clause() IWith_clauseContext { 9630 var t antlr.RuleContext 9631 for _, ctx := range s.GetChildren() { 9632 if _, ok := ctx.(IWith_clauseContext); ok { 9633 t = ctx.(antlr.RuleContext) 9634 break 9635 } 9636 } 9637 9638 if t == nil { 9639 return nil 9640 } 9641 9642 return t.(IWith_clauseContext) 9643 } 9644 9645 func (s *Delete_stmtContext) WHERE_() antlr.TerminalNode { 9646 return s.GetToken(ParserWHERE_, 0) 9647 } 9648 9649 func (s *Delete_stmtContext) Expr() IExprContext { 9650 var t antlr.RuleContext 9651 for _, ctx := range s.GetChildren() { 9652 if _, ok := ctx.(IExprContext); ok { 9653 t = ctx.(antlr.RuleContext) 9654 break 9655 } 9656 } 9657 9658 if t == nil { 9659 return nil 9660 } 9661 9662 return t.(IExprContext) 9663 } 9664 9665 func (s *Delete_stmtContext) Returning_clause() IReturning_clauseContext { 9666 var t antlr.RuleContext 9667 for _, ctx := range s.GetChildren() { 9668 if _, ok := ctx.(IReturning_clauseContext); ok { 9669 t = ctx.(antlr.RuleContext) 9670 break 9671 } 9672 } 9673 9674 if t == nil { 9675 return nil 9676 } 9677 9678 return t.(IReturning_clauseContext) 9679 } 9680 9681 func (s *Delete_stmtContext) GetRuleContext() antlr.RuleContext { 9682 return s 9683 } 9684 9685 func (s *Delete_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 9686 return antlr.TreesStringTree(s, ruleNames, recog) 9687 } 9688 9689 func (s *Delete_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 9690 if listenerT, ok := listener.(ParserListener); ok { 9691 listenerT.EnterDelete_stmt(s) 9692 } 9693 } 9694 9695 func (s *Delete_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 9696 if listenerT, ok := listener.(ParserListener); ok { 9697 listenerT.ExitDelete_stmt(s) 9698 } 9699 } 9700 9701 func (s *Delete_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 9702 switch t := visitor.(type) { 9703 case ParserVisitor: 9704 return t.VisitDelete_stmt(s) 9705 9706 default: 9707 return t.VisitChildren(s) 9708 } 9709 } 9710 9711 func (p *Parser) Delete_stmt() (localctx IDelete_stmtContext) { 9712 this := p 9713 _ = this 9714 9715 localctx = NewDelete_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 9716 p.EnterRule(localctx, 56, ParserRULE_delete_stmt) 9717 var _la int 9718 9719 defer func() { 9720 p.ExitRule() 9721 }() 9722 9723 defer func() { 9724 if err := recover(); err != nil { 9725 if v, ok := err.(antlr.RecognitionException); ok { 9726 localctx.SetException(v) 9727 p.GetErrorHandler().ReportError(p, v) 9728 p.GetErrorHandler().Recover(p, v) 9729 } else { 9730 panic(err) 9731 } 9732 } 9733 }() 9734 9735 p.EnterOuterAlt(localctx, 1) 9736 p.SetState(824) 9737 p.GetErrorHandler().Sync(p) 9738 _la = p.GetTokenStream().LA(1) 9739 9740 if _la == ParserWITH_ { 9741 { 9742 p.SetState(823) 9743 p.With_clause() 9744 } 9745 9746 } 9747 { 9748 p.SetState(826) 9749 p.Match(ParserDELETE_) 9750 } 9751 { 9752 p.SetState(827) 9753 p.Match(ParserFROM_) 9754 } 9755 { 9756 p.SetState(828) 9757 p.Qualified_table_name() 9758 } 9759 p.SetState(831) 9760 p.GetErrorHandler().Sync(p) 9761 _la = p.GetTokenStream().LA(1) 9762 9763 if _la == ParserWHERE_ { 9764 { 9765 p.SetState(829) 9766 p.Match(ParserWHERE_) 9767 } 9768 { 9769 p.SetState(830) 9770 p.expr(0) 9771 } 9772 9773 } 9774 p.SetState(834) 9775 p.GetErrorHandler().Sync(p) 9776 _la = p.GetTokenStream().LA(1) 9777 9778 if _la == ParserRETURNING_ { 9779 { 9780 p.SetState(833) 9781 p.Returning_clause() 9782 } 9783 9784 } 9785 9786 return localctx 9787 } 9788 9789 // IDelete_stmt_limitedContext is an interface to support dynamic dispatch. 9790 type IDelete_stmt_limitedContext interface { 9791 antlr.ParserRuleContext 9792 9793 // GetParser returns the parser. 9794 GetParser() antlr.Parser 9795 9796 // IsDelete_stmt_limitedContext differentiates from other interfaces. 9797 IsDelete_stmt_limitedContext() 9798 } 9799 9800 type Delete_stmt_limitedContext struct { 9801 *antlr.BaseParserRuleContext 9802 parser antlr.Parser 9803 } 9804 9805 func NewEmptyDelete_stmt_limitedContext() *Delete_stmt_limitedContext { 9806 var p = new(Delete_stmt_limitedContext) 9807 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 9808 p.RuleIndex = ParserRULE_delete_stmt_limited 9809 return p 9810 } 9811 9812 func (*Delete_stmt_limitedContext) IsDelete_stmt_limitedContext() {} 9813 9814 func NewDelete_stmt_limitedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Delete_stmt_limitedContext { 9815 var p = new(Delete_stmt_limitedContext) 9816 9817 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 9818 9819 p.parser = parser 9820 p.RuleIndex = ParserRULE_delete_stmt_limited 9821 9822 return p 9823 } 9824 9825 func (s *Delete_stmt_limitedContext) GetParser() antlr.Parser { return s.parser } 9826 9827 func (s *Delete_stmt_limitedContext) DELETE_() antlr.TerminalNode { 9828 return s.GetToken(ParserDELETE_, 0) 9829 } 9830 9831 func (s *Delete_stmt_limitedContext) FROM_() antlr.TerminalNode { 9832 return s.GetToken(ParserFROM_, 0) 9833 } 9834 9835 func (s *Delete_stmt_limitedContext) Qualified_table_name() IQualified_table_nameContext { 9836 var t antlr.RuleContext 9837 for _, ctx := range s.GetChildren() { 9838 if _, ok := ctx.(IQualified_table_nameContext); ok { 9839 t = ctx.(antlr.RuleContext) 9840 break 9841 } 9842 } 9843 9844 if t == nil { 9845 return nil 9846 } 9847 9848 return t.(IQualified_table_nameContext) 9849 } 9850 9851 func (s *Delete_stmt_limitedContext) With_clause() IWith_clauseContext { 9852 var t antlr.RuleContext 9853 for _, ctx := range s.GetChildren() { 9854 if _, ok := ctx.(IWith_clauseContext); ok { 9855 t = ctx.(antlr.RuleContext) 9856 break 9857 } 9858 } 9859 9860 if t == nil { 9861 return nil 9862 } 9863 9864 return t.(IWith_clauseContext) 9865 } 9866 9867 func (s *Delete_stmt_limitedContext) WHERE_() antlr.TerminalNode { 9868 return s.GetToken(ParserWHERE_, 0) 9869 } 9870 9871 func (s *Delete_stmt_limitedContext) Expr() IExprContext { 9872 var t antlr.RuleContext 9873 for _, ctx := range s.GetChildren() { 9874 if _, ok := ctx.(IExprContext); ok { 9875 t = ctx.(antlr.RuleContext) 9876 break 9877 } 9878 } 9879 9880 if t == nil { 9881 return nil 9882 } 9883 9884 return t.(IExprContext) 9885 } 9886 9887 func (s *Delete_stmt_limitedContext) Returning_clause() IReturning_clauseContext { 9888 var t antlr.RuleContext 9889 for _, ctx := range s.GetChildren() { 9890 if _, ok := ctx.(IReturning_clauseContext); ok { 9891 t = ctx.(antlr.RuleContext) 9892 break 9893 } 9894 } 9895 9896 if t == nil { 9897 return nil 9898 } 9899 9900 return t.(IReturning_clauseContext) 9901 } 9902 9903 func (s *Delete_stmt_limitedContext) Limit_stmt() ILimit_stmtContext { 9904 var t antlr.RuleContext 9905 for _, ctx := range s.GetChildren() { 9906 if _, ok := ctx.(ILimit_stmtContext); ok { 9907 t = ctx.(antlr.RuleContext) 9908 break 9909 } 9910 } 9911 9912 if t == nil { 9913 return nil 9914 } 9915 9916 return t.(ILimit_stmtContext) 9917 } 9918 9919 func (s *Delete_stmt_limitedContext) Order_by_stmt() IOrder_by_stmtContext { 9920 var t antlr.RuleContext 9921 for _, ctx := range s.GetChildren() { 9922 if _, ok := ctx.(IOrder_by_stmtContext); ok { 9923 t = ctx.(antlr.RuleContext) 9924 break 9925 } 9926 } 9927 9928 if t == nil { 9929 return nil 9930 } 9931 9932 return t.(IOrder_by_stmtContext) 9933 } 9934 9935 func (s *Delete_stmt_limitedContext) GetRuleContext() antlr.RuleContext { 9936 return s 9937 } 9938 9939 func (s *Delete_stmt_limitedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 9940 return antlr.TreesStringTree(s, ruleNames, recog) 9941 } 9942 9943 func (s *Delete_stmt_limitedContext) EnterRule(listener antlr.ParseTreeListener) { 9944 if listenerT, ok := listener.(ParserListener); ok { 9945 listenerT.EnterDelete_stmt_limited(s) 9946 } 9947 } 9948 9949 func (s *Delete_stmt_limitedContext) ExitRule(listener antlr.ParseTreeListener) { 9950 if listenerT, ok := listener.(ParserListener); ok { 9951 listenerT.ExitDelete_stmt_limited(s) 9952 } 9953 } 9954 9955 func (s *Delete_stmt_limitedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 9956 switch t := visitor.(type) { 9957 case ParserVisitor: 9958 return t.VisitDelete_stmt_limited(s) 9959 9960 default: 9961 return t.VisitChildren(s) 9962 } 9963 } 9964 9965 func (p *Parser) Delete_stmt_limited() (localctx IDelete_stmt_limitedContext) { 9966 this := p 9967 _ = this 9968 9969 localctx = NewDelete_stmt_limitedContext(p, p.GetParserRuleContext(), p.GetState()) 9970 p.EnterRule(localctx, 58, ParserRULE_delete_stmt_limited) 9971 var _la int 9972 9973 defer func() { 9974 p.ExitRule() 9975 }() 9976 9977 defer func() { 9978 if err := recover(); err != nil { 9979 if v, ok := err.(antlr.RecognitionException); ok { 9980 localctx.SetException(v) 9981 p.GetErrorHandler().ReportError(p, v) 9982 p.GetErrorHandler().Recover(p, v) 9983 } else { 9984 panic(err) 9985 } 9986 } 9987 }() 9988 9989 p.EnterOuterAlt(localctx, 1) 9990 p.SetState(837) 9991 p.GetErrorHandler().Sync(p) 9992 _la = p.GetTokenStream().LA(1) 9993 9994 if _la == ParserWITH_ { 9995 { 9996 p.SetState(836) 9997 p.With_clause() 9998 } 9999 10000 } 10001 { 10002 p.SetState(839) 10003 p.Match(ParserDELETE_) 10004 } 10005 { 10006 p.SetState(840) 10007 p.Match(ParserFROM_) 10008 } 10009 { 10010 p.SetState(841) 10011 p.Qualified_table_name() 10012 } 10013 p.SetState(844) 10014 p.GetErrorHandler().Sync(p) 10015 _la = p.GetTokenStream().LA(1) 10016 10017 if _la == ParserWHERE_ { 10018 { 10019 p.SetState(842) 10020 p.Match(ParserWHERE_) 10021 } 10022 { 10023 p.SetState(843) 10024 p.expr(0) 10025 } 10026 10027 } 10028 p.SetState(847) 10029 p.GetErrorHandler().Sync(p) 10030 _la = p.GetTokenStream().LA(1) 10031 10032 if _la == ParserRETURNING_ { 10033 { 10034 p.SetState(846) 10035 p.Returning_clause() 10036 } 10037 10038 } 10039 p.SetState(853) 10040 p.GetErrorHandler().Sync(p) 10041 _la = p.GetTokenStream().LA(1) 10042 10043 if _la == ParserLIMIT_ || _la == ParserORDER_ { 10044 p.SetState(850) 10045 p.GetErrorHandler().Sync(p) 10046 _la = p.GetTokenStream().LA(1) 10047 10048 if _la == ParserORDER_ { 10049 { 10050 p.SetState(849) 10051 p.Order_by_stmt() 10052 } 10053 10054 } 10055 { 10056 p.SetState(852) 10057 p.Limit_stmt() 10058 } 10059 10060 } 10061 10062 return localctx 10063 } 10064 10065 // IDetach_stmtContext is an interface to support dynamic dispatch. 10066 type IDetach_stmtContext interface { 10067 antlr.ParserRuleContext 10068 10069 // GetParser returns the parser. 10070 GetParser() antlr.Parser 10071 10072 // IsDetach_stmtContext differentiates from other interfaces. 10073 IsDetach_stmtContext() 10074 } 10075 10076 type Detach_stmtContext struct { 10077 *antlr.BaseParserRuleContext 10078 parser antlr.Parser 10079 } 10080 10081 func NewEmptyDetach_stmtContext() *Detach_stmtContext { 10082 var p = new(Detach_stmtContext) 10083 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 10084 p.RuleIndex = ParserRULE_detach_stmt 10085 return p 10086 } 10087 10088 func (*Detach_stmtContext) IsDetach_stmtContext() {} 10089 10090 func NewDetach_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Detach_stmtContext { 10091 var p = new(Detach_stmtContext) 10092 10093 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 10094 10095 p.parser = parser 10096 p.RuleIndex = ParserRULE_detach_stmt 10097 10098 return p 10099 } 10100 10101 func (s *Detach_stmtContext) GetParser() antlr.Parser { return s.parser } 10102 10103 func (s *Detach_stmtContext) DETACH_() antlr.TerminalNode { 10104 return s.GetToken(ParserDETACH_, 0) 10105 } 10106 10107 func (s *Detach_stmtContext) Schema_name() ISchema_nameContext { 10108 var t antlr.RuleContext 10109 for _, ctx := range s.GetChildren() { 10110 if _, ok := ctx.(ISchema_nameContext); ok { 10111 t = ctx.(antlr.RuleContext) 10112 break 10113 } 10114 } 10115 10116 if t == nil { 10117 return nil 10118 } 10119 10120 return t.(ISchema_nameContext) 10121 } 10122 10123 func (s *Detach_stmtContext) DATABASE_() antlr.TerminalNode { 10124 return s.GetToken(ParserDATABASE_, 0) 10125 } 10126 10127 func (s *Detach_stmtContext) GetRuleContext() antlr.RuleContext { 10128 return s 10129 } 10130 10131 func (s *Detach_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 10132 return antlr.TreesStringTree(s, ruleNames, recog) 10133 } 10134 10135 func (s *Detach_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 10136 if listenerT, ok := listener.(ParserListener); ok { 10137 listenerT.EnterDetach_stmt(s) 10138 } 10139 } 10140 10141 func (s *Detach_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 10142 if listenerT, ok := listener.(ParserListener); ok { 10143 listenerT.ExitDetach_stmt(s) 10144 } 10145 } 10146 10147 func (s *Detach_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 10148 switch t := visitor.(type) { 10149 case ParserVisitor: 10150 return t.VisitDetach_stmt(s) 10151 10152 default: 10153 return t.VisitChildren(s) 10154 } 10155 } 10156 10157 func (p *Parser) Detach_stmt() (localctx IDetach_stmtContext) { 10158 this := p 10159 _ = this 10160 10161 localctx = NewDetach_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 10162 p.EnterRule(localctx, 60, ParserRULE_detach_stmt) 10163 10164 defer func() { 10165 p.ExitRule() 10166 }() 10167 10168 defer func() { 10169 if err := recover(); err != nil { 10170 if v, ok := err.(antlr.RecognitionException); ok { 10171 localctx.SetException(v) 10172 p.GetErrorHandler().ReportError(p, v) 10173 p.GetErrorHandler().Recover(p, v) 10174 } else { 10175 panic(err) 10176 } 10177 } 10178 }() 10179 10180 p.EnterOuterAlt(localctx, 1) 10181 { 10182 p.SetState(855) 10183 p.Match(ParserDETACH_) 10184 } 10185 p.SetState(857) 10186 p.GetErrorHandler().Sync(p) 10187 10188 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 104, p.GetParserRuleContext()) == 1 { 10189 { 10190 p.SetState(856) 10191 p.Match(ParserDATABASE_) 10192 } 10193 10194 } 10195 { 10196 p.SetState(859) 10197 p.Schema_name() 10198 } 10199 10200 return localctx 10201 } 10202 10203 // IDrop_stmtContext is an interface to support dynamic dispatch. 10204 type IDrop_stmtContext interface { 10205 antlr.ParserRuleContext 10206 10207 // GetParser returns the parser. 10208 GetParser() antlr.Parser 10209 10210 // GetObject returns the object token. 10211 GetObject() antlr.Token 10212 10213 // SetObject sets the object token. 10214 SetObject(antlr.Token) 10215 10216 // IsDrop_stmtContext differentiates from other interfaces. 10217 IsDrop_stmtContext() 10218 } 10219 10220 type Drop_stmtContext struct { 10221 *antlr.BaseParserRuleContext 10222 parser antlr.Parser 10223 object antlr.Token 10224 } 10225 10226 func NewEmptyDrop_stmtContext() *Drop_stmtContext { 10227 var p = new(Drop_stmtContext) 10228 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 10229 p.RuleIndex = ParserRULE_drop_stmt 10230 return p 10231 } 10232 10233 func (*Drop_stmtContext) IsDrop_stmtContext() {} 10234 10235 func NewDrop_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_stmtContext { 10236 var p = new(Drop_stmtContext) 10237 10238 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 10239 10240 p.parser = parser 10241 p.RuleIndex = ParserRULE_drop_stmt 10242 10243 return p 10244 } 10245 10246 func (s *Drop_stmtContext) GetParser() antlr.Parser { return s.parser } 10247 10248 func (s *Drop_stmtContext) GetObject() antlr.Token { return s.object } 10249 10250 func (s *Drop_stmtContext) SetObject(v antlr.Token) { s.object = v } 10251 10252 func (s *Drop_stmtContext) DROP_() antlr.TerminalNode { 10253 return s.GetToken(ParserDROP_, 0) 10254 } 10255 10256 func (s *Drop_stmtContext) Any_name() IAny_nameContext { 10257 var t antlr.RuleContext 10258 for _, ctx := range s.GetChildren() { 10259 if _, ok := ctx.(IAny_nameContext); ok { 10260 t = ctx.(antlr.RuleContext) 10261 break 10262 } 10263 } 10264 10265 if t == nil { 10266 return nil 10267 } 10268 10269 return t.(IAny_nameContext) 10270 } 10271 10272 func (s *Drop_stmtContext) INDEX_() antlr.TerminalNode { 10273 return s.GetToken(ParserINDEX_, 0) 10274 } 10275 10276 func (s *Drop_stmtContext) TABLE_() antlr.TerminalNode { 10277 return s.GetToken(ParserTABLE_, 0) 10278 } 10279 10280 func (s *Drop_stmtContext) TRIGGER_() antlr.TerminalNode { 10281 return s.GetToken(ParserTRIGGER_, 0) 10282 } 10283 10284 func (s *Drop_stmtContext) VIEW_() antlr.TerminalNode { 10285 return s.GetToken(ParserVIEW_, 0) 10286 } 10287 10288 func (s *Drop_stmtContext) IF_() antlr.TerminalNode { 10289 return s.GetToken(ParserIF_, 0) 10290 } 10291 10292 func (s *Drop_stmtContext) EXISTS_() antlr.TerminalNode { 10293 return s.GetToken(ParserEXISTS_, 0) 10294 } 10295 10296 func (s *Drop_stmtContext) Schema_name() ISchema_nameContext { 10297 var t antlr.RuleContext 10298 for _, ctx := range s.GetChildren() { 10299 if _, ok := ctx.(ISchema_nameContext); ok { 10300 t = ctx.(antlr.RuleContext) 10301 break 10302 } 10303 } 10304 10305 if t == nil { 10306 return nil 10307 } 10308 10309 return t.(ISchema_nameContext) 10310 } 10311 10312 func (s *Drop_stmtContext) DOT() antlr.TerminalNode { 10313 return s.GetToken(ParserDOT, 0) 10314 } 10315 10316 func (s *Drop_stmtContext) GetRuleContext() antlr.RuleContext { 10317 return s 10318 } 10319 10320 func (s *Drop_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 10321 return antlr.TreesStringTree(s, ruleNames, recog) 10322 } 10323 10324 func (s *Drop_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 10325 if listenerT, ok := listener.(ParserListener); ok { 10326 listenerT.EnterDrop_stmt(s) 10327 } 10328 } 10329 10330 func (s *Drop_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 10331 if listenerT, ok := listener.(ParserListener); ok { 10332 listenerT.ExitDrop_stmt(s) 10333 } 10334 } 10335 10336 func (s *Drop_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 10337 switch t := visitor.(type) { 10338 case ParserVisitor: 10339 return t.VisitDrop_stmt(s) 10340 10341 default: 10342 return t.VisitChildren(s) 10343 } 10344 } 10345 10346 func (p *Parser) Drop_stmt() (localctx IDrop_stmtContext) { 10347 this := p 10348 _ = this 10349 10350 localctx = NewDrop_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 10351 p.EnterRule(localctx, 62, ParserRULE_drop_stmt) 10352 var _la int 10353 10354 defer func() { 10355 p.ExitRule() 10356 }() 10357 10358 defer func() { 10359 if err := recover(); err != nil { 10360 if v, ok := err.(antlr.RecognitionException); ok { 10361 localctx.SetException(v) 10362 p.GetErrorHandler().ReportError(p, v) 10363 p.GetErrorHandler().Recover(p, v) 10364 } else { 10365 panic(err) 10366 } 10367 } 10368 }() 10369 10370 p.EnterOuterAlt(localctx, 1) 10371 { 10372 p.SetState(861) 10373 p.Match(ParserDROP_) 10374 } 10375 { 10376 p.SetState(862) 10377 10378 var _lt = p.GetTokenStream().LT(1) 10379 10380 localctx.(*Drop_stmtContext).object = _lt 10381 10382 _la = p.GetTokenStream().LA(1) 10383 10384 if !(_la == ParserINDEX_ || (((_la-132)&-(0x1f+1)) == 0 && ((1<<uint((_la-132)))&((1<<(ParserTABLE_-132))|(1<<(ParserTRIGGER_-132))|(1<<(ParserVIEW_-132)))) != 0)) { 10385 var _ri = p.GetErrorHandler().RecoverInline(p) 10386 10387 localctx.(*Drop_stmtContext).object = _ri 10388 } else { 10389 p.GetErrorHandler().ReportMatch(p) 10390 p.Consume() 10391 } 10392 } 10393 p.SetState(865) 10394 p.GetErrorHandler().Sync(p) 10395 10396 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 105, p.GetParserRuleContext()) == 1 { 10397 { 10398 p.SetState(863) 10399 p.Match(ParserIF_) 10400 } 10401 { 10402 p.SetState(864) 10403 p.Match(ParserEXISTS_) 10404 } 10405 10406 } 10407 p.SetState(870) 10408 p.GetErrorHandler().Sync(p) 10409 10410 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 106, p.GetParserRuleContext()) == 1 { 10411 { 10412 p.SetState(867) 10413 p.Schema_name() 10414 } 10415 { 10416 p.SetState(868) 10417 p.Match(ParserDOT) 10418 } 10419 10420 } 10421 { 10422 p.SetState(872) 10423 p.Any_name() 10424 } 10425 10426 return localctx 10427 } 10428 10429 // IExprContext is an interface to support dynamic dispatch. 10430 type IExprContext interface { 10431 antlr.ParserRuleContext 10432 10433 // GetParser returns the parser. 10434 GetParser() antlr.Parser 10435 10436 // IsExprContext differentiates from other interfaces. 10437 IsExprContext() 10438 } 10439 10440 type ExprContext struct { 10441 *antlr.BaseParserRuleContext 10442 parser antlr.Parser 10443 } 10444 10445 func NewEmptyExprContext() *ExprContext { 10446 var p = new(ExprContext) 10447 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 10448 p.RuleIndex = ParserRULE_expr 10449 return p 10450 } 10451 10452 func (*ExprContext) IsExprContext() {} 10453 10454 func NewExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExprContext { 10455 var p = new(ExprContext) 10456 10457 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 10458 10459 p.parser = parser 10460 p.RuleIndex = ParserRULE_expr 10461 10462 return p 10463 } 10464 10465 func (s *ExprContext) GetParser() antlr.Parser { return s.parser } 10466 10467 func (s *ExprContext) Literal_value() ILiteral_valueContext { 10468 var t antlr.RuleContext 10469 for _, ctx := range s.GetChildren() { 10470 if _, ok := ctx.(ILiteral_valueContext); ok { 10471 t = ctx.(antlr.RuleContext) 10472 break 10473 } 10474 } 10475 10476 if t == nil { 10477 return nil 10478 } 10479 10480 return t.(ILiteral_valueContext) 10481 } 10482 10483 func (s *ExprContext) BIND_PARAMETER() antlr.TerminalNode { 10484 return s.GetToken(ParserBIND_PARAMETER, 0) 10485 } 10486 10487 func (s *ExprContext) Column_name() IColumn_nameContext { 10488 var t antlr.RuleContext 10489 for _, ctx := range s.GetChildren() { 10490 if _, ok := ctx.(IColumn_nameContext); ok { 10491 t = ctx.(antlr.RuleContext) 10492 break 10493 } 10494 } 10495 10496 if t == nil { 10497 return nil 10498 } 10499 10500 return t.(IColumn_nameContext) 10501 } 10502 10503 func (s *ExprContext) Table_name() ITable_nameContext { 10504 var t antlr.RuleContext 10505 for _, ctx := range s.GetChildren() { 10506 if _, ok := ctx.(ITable_nameContext); ok { 10507 t = ctx.(antlr.RuleContext) 10508 break 10509 } 10510 } 10511 10512 if t == nil { 10513 return nil 10514 } 10515 10516 return t.(ITable_nameContext) 10517 } 10518 10519 func (s *ExprContext) AllDOT() []antlr.TerminalNode { 10520 return s.GetTokens(ParserDOT) 10521 } 10522 10523 func (s *ExprContext) DOT(i int) antlr.TerminalNode { 10524 return s.GetToken(ParserDOT, i) 10525 } 10526 10527 func (s *ExprContext) Schema_name() ISchema_nameContext { 10528 var t antlr.RuleContext 10529 for _, ctx := range s.GetChildren() { 10530 if _, ok := ctx.(ISchema_nameContext); ok { 10531 t = ctx.(antlr.RuleContext) 10532 break 10533 } 10534 } 10535 10536 if t == nil { 10537 return nil 10538 } 10539 10540 return t.(ISchema_nameContext) 10541 } 10542 10543 func (s *ExprContext) Unary_operator() IUnary_operatorContext { 10544 var t antlr.RuleContext 10545 for _, ctx := range s.GetChildren() { 10546 if _, ok := ctx.(IUnary_operatorContext); ok { 10547 t = ctx.(antlr.RuleContext) 10548 break 10549 } 10550 } 10551 10552 if t == nil { 10553 return nil 10554 } 10555 10556 return t.(IUnary_operatorContext) 10557 } 10558 10559 func (s *ExprContext) AllExpr() []IExprContext { 10560 children := s.GetChildren() 10561 len := 0 10562 for _, ctx := range children { 10563 if _, ok := ctx.(IExprContext); ok { 10564 len++ 10565 } 10566 } 10567 10568 tst := make([]IExprContext, len) 10569 i := 0 10570 for _, ctx := range children { 10571 if t, ok := ctx.(IExprContext); ok { 10572 tst[i] = t.(IExprContext) 10573 i++ 10574 } 10575 } 10576 10577 return tst 10578 } 10579 10580 func (s *ExprContext) Expr(i int) IExprContext { 10581 var t antlr.RuleContext 10582 j := 0 10583 for _, ctx := range s.GetChildren() { 10584 if _, ok := ctx.(IExprContext); ok { 10585 if j == i { 10586 t = ctx.(antlr.RuleContext) 10587 break 10588 } 10589 j++ 10590 } 10591 } 10592 10593 if t == nil { 10594 return nil 10595 } 10596 10597 return t.(IExprContext) 10598 } 10599 10600 func (s *ExprContext) Function_name() IFunction_nameContext { 10601 var t antlr.RuleContext 10602 for _, ctx := range s.GetChildren() { 10603 if _, ok := ctx.(IFunction_nameContext); ok { 10604 t = ctx.(antlr.RuleContext) 10605 break 10606 } 10607 } 10608 10609 if t == nil { 10610 return nil 10611 } 10612 10613 return t.(IFunction_nameContext) 10614 } 10615 10616 func (s *ExprContext) OPEN_PAR() antlr.TerminalNode { 10617 return s.GetToken(ParserOPEN_PAR, 0) 10618 } 10619 10620 func (s *ExprContext) CLOSE_PAR() antlr.TerminalNode { 10621 return s.GetToken(ParserCLOSE_PAR, 0) 10622 } 10623 10624 func (s *ExprContext) STAR() antlr.TerminalNode { 10625 return s.GetToken(ParserSTAR, 0) 10626 } 10627 10628 func (s *ExprContext) Filter_clause() IFilter_clauseContext { 10629 var t antlr.RuleContext 10630 for _, ctx := range s.GetChildren() { 10631 if _, ok := ctx.(IFilter_clauseContext); ok { 10632 t = ctx.(antlr.RuleContext) 10633 break 10634 } 10635 } 10636 10637 if t == nil { 10638 return nil 10639 } 10640 10641 return t.(IFilter_clauseContext) 10642 } 10643 10644 func (s *ExprContext) Over_clause() IOver_clauseContext { 10645 var t antlr.RuleContext 10646 for _, ctx := range s.GetChildren() { 10647 if _, ok := ctx.(IOver_clauseContext); ok { 10648 t = ctx.(antlr.RuleContext) 10649 break 10650 } 10651 } 10652 10653 if t == nil { 10654 return nil 10655 } 10656 10657 return t.(IOver_clauseContext) 10658 } 10659 10660 func (s *ExprContext) DISTINCT_() antlr.TerminalNode { 10661 return s.GetToken(ParserDISTINCT_, 0) 10662 } 10663 10664 func (s *ExprContext) AllCOMMA() []antlr.TerminalNode { 10665 return s.GetTokens(ParserCOMMA) 10666 } 10667 10668 func (s *ExprContext) COMMA(i int) antlr.TerminalNode { 10669 return s.GetToken(ParserCOMMA, i) 10670 } 10671 10672 func (s *ExprContext) CAST_() antlr.TerminalNode { 10673 return s.GetToken(ParserCAST_, 0) 10674 } 10675 10676 func (s *ExprContext) AS_() antlr.TerminalNode { 10677 return s.GetToken(ParserAS_, 0) 10678 } 10679 10680 func (s *ExprContext) Type_name() IType_nameContext { 10681 var t antlr.RuleContext 10682 for _, ctx := range s.GetChildren() { 10683 if _, ok := ctx.(IType_nameContext); ok { 10684 t = ctx.(antlr.RuleContext) 10685 break 10686 } 10687 } 10688 10689 if t == nil { 10690 return nil 10691 } 10692 10693 return t.(IType_nameContext) 10694 } 10695 10696 func (s *ExprContext) Select_stmt() ISelect_stmtContext { 10697 var t antlr.RuleContext 10698 for _, ctx := range s.GetChildren() { 10699 if _, ok := ctx.(ISelect_stmtContext); ok { 10700 t = ctx.(antlr.RuleContext) 10701 break 10702 } 10703 } 10704 10705 if t == nil { 10706 return nil 10707 } 10708 10709 return t.(ISelect_stmtContext) 10710 } 10711 10712 func (s *ExprContext) EXISTS_() antlr.TerminalNode { 10713 return s.GetToken(ParserEXISTS_, 0) 10714 } 10715 10716 func (s *ExprContext) NOT_() antlr.TerminalNode { 10717 return s.GetToken(ParserNOT_, 0) 10718 } 10719 10720 func (s *ExprContext) CASE_() antlr.TerminalNode { 10721 return s.GetToken(ParserCASE_, 0) 10722 } 10723 10724 func (s *ExprContext) END_() antlr.TerminalNode { 10725 return s.GetToken(ParserEND_, 0) 10726 } 10727 10728 func (s *ExprContext) AllWHEN_() []antlr.TerminalNode { 10729 return s.GetTokens(ParserWHEN_) 10730 } 10731 10732 func (s *ExprContext) WHEN_(i int) antlr.TerminalNode { 10733 return s.GetToken(ParserWHEN_, i) 10734 } 10735 10736 func (s *ExprContext) AllTHEN_() []antlr.TerminalNode { 10737 return s.GetTokens(ParserTHEN_) 10738 } 10739 10740 func (s *ExprContext) THEN_(i int) antlr.TerminalNode { 10741 return s.GetToken(ParserTHEN_, i) 10742 } 10743 10744 func (s *ExprContext) ELSE_() antlr.TerminalNode { 10745 return s.GetToken(ParserELSE_, 0) 10746 } 10747 10748 func (s *ExprContext) Raise_function() IRaise_functionContext { 10749 var t antlr.RuleContext 10750 for _, ctx := range s.GetChildren() { 10751 if _, ok := ctx.(IRaise_functionContext); ok { 10752 t = ctx.(antlr.RuleContext) 10753 break 10754 } 10755 } 10756 10757 if t == nil { 10758 return nil 10759 } 10760 10761 return t.(IRaise_functionContext) 10762 } 10763 10764 func (s *ExprContext) PIPE2() antlr.TerminalNode { 10765 return s.GetToken(ParserPIPE2, 0) 10766 } 10767 10768 func (s *ExprContext) DIV() antlr.TerminalNode { 10769 return s.GetToken(ParserDIV, 0) 10770 } 10771 10772 func (s *ExprContext) MOD() antlr.TerminalNode { 10773 return s.GetToken(ParserMOD, 0) 10774 } 10775 10776 func (s *ExprContext) PLUS() antlr.TerminalNode { 10777 return s.GetToken(ParserPLUS, 0) 10778 } 10779 10780 func (s *ExprContext) MINUS() antlr.TerminalNode { 10781 return s.GetToken(ParserMINUS, 0) 10782 } 10783 10784 func (s *ExprContext) LT2() antlr.TerminalNode { 10785 return s.GetToken(ParserLT2, 0) 10786 } 10787 10788 func (s *ExprContext) GT2() antlr.TerminalNode { 10789 return s.GetToken(ParserGT2, 0) 10790 } 10791 10792 func (s *ExprContext) AMP() antlr.TerminalNode { 10793 return s.GetToken(ParserAMP, 0) 10794 } 10795 10796 func (s *ExprContext) PIPE() antlr.TerminalNode { 10797 return s.GetToken(ParserPIPE, 0) 10798 } 10799 10800 func (s *ExprContext) LT() antlr.TerminalNode { 10801 return s.GetToken(ParserLT, 0) 10802 } 10803 10804 func (s *ExprContext) LT_EQ() antlr.TerminalNode { 10805 return s.GetToken(ParserLT_EQ, 0) 10806 } 10807 10808 func (s *ExprContext) GT() antlr.TerminalNode { 10809 return s.GetToken(ParserGT, 0) 10810 } 10811 10812 func (s *ExprContext) GT_EQ() antlr.TerminalNode { 10813 return s.GetToken(ParserGT_EQ, 0) 10814 } 10815 10816 func (s *ExprContext) ASSIGN() antlr.TerminalNode { 10817 return s.GetToken(ParserASSIGN, 0) 10818 } 10819 10820 func (s *ExprContext) EQ() antlr.TerminalNode { 10821 return s.GetToken(ParserEQ, 0) 10822 } 10823 10824 func (s *ExprContext) NOT_EQ1() antlr.TerminalNode { 10825 return s.GetToken(ParserNOT_EQ1, 0) 10826 } 10827 10828 func (s *ExprContext) NOT_EQ2() antlr.TerminalNode { 10829 return s.GetToken(ParserNOT_EQ2, 0) 10830 } 10831 10832 func (s *ExprContext) IS_() antlr.TerminalNode { 10833 return s.GetToken(ParserIS_, 0) 10834 } 10835 10836 func (s *ExprContext) IN_() antlr.TerminalNode { 10837 return s.GetToken(ParserIN_, 0) 10838 } 10839 10840 func (s *ExprContext) LIKE_() antlr.TerminalNode { 10841 return s.GetToken(ParserLIKE_, 0) 10842 } 10843 10844 func (s *ExprContext) GLOB_() antlr.TerminalNode { 10845 return s.GetToken(ParserGLOB_, 0) 10846 } 10847 10848 func (s *ExprContext) MATCH_() antlr.TerminalNode { 10849 return s.GetToken(ParserMATCH_, 0) 10850 } 10851 10852 func (s *ExprContext) REGEXP_() antlr.TerminalNode { 10853 return s.GetToken(ParserREGEXP_, 0) 10854 } 10855 10856 func (s *ExprContext) AND_() antlr.TerminalNode { 10857 return s.GetToken(ParserAND_, 0) 10858 } 10859 10860 func (s *ExprContext) OR_() antlr.TerminalNode { 10861 return s.GetToken(ParserOR_, 0) 10862 } 10863 10864 func (s *ExprContext) BETWEEN_() antlr.TerminalNode { 10865 return s.GetToken(ParserBETWEEN_, 0) 10866 } 10867 10868 func (s *ExprContext) COLLATE_() antlr.TerminalNode { 10869 return s.GetToken(ParserCOLLATE_, 0) 10870 } 10871 10872 func (s *ExprContext) Collation_name() ICollation_nameContext { 10873 var t antlr.RuleContext 10874 for _, ctx := range s.GetChildren() { 10875 if _, ok := ctx.(ICollation_nameContext); ok { 10876 t = ctx.(antlr.RuleContext) 10877 break 10878 } 10879 } 10880 10881 if t == nil { 10882 return nil 10883 } 10884 10885 return t.(ICollation_nameContext) 10886 } 10887 10888 func (s *ExprContext) ESCAPE_() antlr.TerminalNode { 10889 return s.GetToken(ParserESCAPE_, 0) 10890 } 10891 10892 func (s *ExprContext) ISNULL_() antlr.TerminalNode { 10893 return s.GetToken(ParserISNULL_, 0) 10894 } 10895 10896 func (s *ExprContext) NOTNULL_() antlr.TerminalNode { 10897 return s.GetToken(ParserNOTNULL_, 0) 10898 } 10899 10900 func (s *ExprContext) NULL_() antlr.TerminalNode { 10901 return s.GetToken(ParserNULL_, 0) 10902 } 10903 10904 func (s *ExprContext) Table_function_name() ITable_function_nameContext { 10905 var t antlr.RuleContext 10906 for _, ctx := range s.GetChildren() { 10907 if _, ok := ctx.(ITable_function_nameContext); ok { 10908 t = ctx.(antlr.RuleContext) 10909 break 10910 } 10911 } 10912 10913 if t == nil { 10914 return nil 10915 } 10916 10917 return t.(ITable_function_nameContext) 10918 } 10919 10920 func (s *ExprContext) GetRuleContext() antlr.RuleContext { 10921 return s 10922 } 10923 10924 func (s *ExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 10925 return antlr.TreesStringTree(s, ruleNames, recog) 10926 } 10927 10928 func (s *ExprContext) EnterRule(listener antlr.ParseTreeListener) { 10929 if listenerT, ok := listener.(ParserListener); ok { 10930 listenerT.EnterExpr(s) 10931 } 10932 } 10933 10934 func (s *ExprContext) ExitRule(listener antlr.ParseTreeListener) { 10935 if listenerT, ok := listener.(ParserListener); ok { 10936 listenerT.ExitExpr(s) 10937 } 10938 } 10939 10940 func (s *ExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 10941 switch t := visitor.(type) { 10942 case ParserVisitor: 10943 return t.VisitExpr(s) 10944 10945 default: 10946 return t.VisitChildren(s) 10947 } 10948 } 10949 10950 func (p *Parser) Expr() (localctx IExprContext) { 10951 return p.expr(0) 10952 } 10953 10954 func (p *Parser) expr(_p int) (localctx IExprContext) { 10955 this := p 10956 _ = this 10957 10958 var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() 10959 _parentState := p.GetState() 10960 localctx = NewExprContext(p, p.GetParserRuleContext(), _parentState) 10961 var _prevctx IExprContext = localctx 10962 var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. 10963 _startState := 64 10964 p.EnterRecursionRule(localctx, 64, ParserRULE_expr, _p) 10965 var _la int 10966 10967 defer func() { 10968 p.UnrollRecursionContexts(_parentctx) 10969 }() 10970 10971 defer func() { 10972 if err := recover(); err != nil { 10973 if v, ok := err.(antlr.RecognitionException); ok { 10974 localctx.SetException(v) 10975 p.GetErrorHandler().ReportError(p, v) 10976 p.GetErrorHandler().Recover(p, v) 10977 } else { 10978 panic(err) 10979 } 10980 } 10981 }() 10982 10983 var _alt int 10984 10985 p.EnterOuterAlt(localctx, 1) 10986 p.SetState(962) 10987 p.GetErrorHandler().Sync(p) 10988 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 120, p.GetParserRuleContext()) { 10989 case 1: 10990 { 10991 p.SetState(875) 10992 p.Literal_value() 10993 } 10994 10995 case 2: 10996 { 10997 p.SetState(876) 10998 p.Match(ParserBIND_PARAMETER) 10999 } 11000 11001 case 3: 11002 p.SetState(885) 11003 p.GetErrorHandler().Sync(p) 11004 11005 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 108, p.GetParserRuleContext()) == 1 { 11006 p.SetState(880) 11007 p.GetErrorHandler().Sync(p) 11008 11009 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 107, p.GetParserRuleContext()) == 1 { 11010 { 11011 p.SetState(877) 11012 p.Schema_name() 11013 } 11014 { 11015 p.SetState(878) 11016 p.Match(ParserDOT) 11017 } 11018 11019 } 11020 { 11021 p.SetState(882) 11022 p.Table_name() 11023 } 11024 { 11025 p.SetState(883) 11026 p.Match(ParserDOT) 11027 } 11028 11029 } 11030 { 11031 p.SetState(887) 11032 p.Column_name() 11033 } 11034 11035 case 4: 11036 { 11037 p.SetState(888) 11038 p.Unary_operator() 11039 } 11040 { 11041 p.SetState(889) 11042 p.expr(21) 11043 } 11044 11045 case 5: 11046 { 11047 p.SetState(891) 11048 p.Function_name() 11049 } 11050 { 11051 p.SetState(892) 11052 p.Match(ParserOPEN_PAR) 11053 } 11054 p.SetState(905) 11055 p.GetErrorHandler().Sync(p) 11056 11057 switch p.GetTokenStream().LA(1) { 11058 case ParserOPEN_PAR, ParserPLUS, ParserMINUS, ParserTILDE, ParserABORT_, ParserACTION_, ParserADD_, ParserAFTER_, ParserALL_, ParserALTER_, ParserANALYZE_, ParserAND_, ParserAS_, ParserASC_, ParserATTACH_, ParserAUTOINCREMENT_, ParserBEFORE_, ParserBEGIN_, ParserBETWEEN_, ParserBY_, ParserCASCADE_, ParserCASE_, ParserCAST_, ParserCHECK_, ParserCOLLATE_, ParserCOLUMN_, ParserCOMMIT_, ParserCONFLICT_, ParserCONSTRAINT_, ParserCREATE_, ParserCROSS_, ParserCURRENT_DATE_, ParserCURRENT_TIME_, ParserCURRENT_TIMESTAMP_, ParserDATABASE_, ParserDEFAULT_, ParserDEFERRABLE_, ParserDEFERRED_, ParserDELETE_, ParserDESC_, ParserDETACH_, ParserDISTINCT_, ParserDROP_, ParserEACH_, ParserELSE_, ParserEND_, ParserESCAPE_, ParserEXCEPT_, ParserEXCLUSIVE_, ParserEXISTS_, ParserEXPLAIN_, ParserFAIL_, ParserFOR_, ParserFOREIGN_, ParserFROM_, ParserFULL_, ParserGLOB_, ParserGROUP_, ParserHAVING_, ParserIF_, ParserIGNORE_, ParserIMMEDIATE_, ParserIN_, ParserINDEX_, ParserINDEXED_, ParserINITIALLY_, ParserINNER_, ParserINSERT_, ParserINSTEAD_, ParserINTERSECT_, ParserINTO_, ParserIS_, ParserISNULL_, ParserJOIN_, ParserKEY_, ParserLEFT_, ParserLIKE_, ParserLIMIT_, ParserMATCH_, ParserNATURAL_, ParserNO_, ParserNOT_, ParserNOTNULL_, ParserNULL_, ParserOF_, ParserOFFSET_, ParserON_, ParserOR_, ParserORDER_, ParserOUTER_, ParserPLAN_, ParserPRAGMA_, ParserPRIMARY_, ParserQUERY_, ParserRAISE_, ParserRECURSIVE_, ParserREFERENCES_, ParserREGEXP_, ParserREINDEX_, ParserRELEASE_, ParserRENAME_, ParserREPLACE_, ParserRESTRICT_, ParserRIGHT_, ParserROLLBACK_, ParserROW_, ParserROWS_, ParserSAVEPOINT_, ParserSELECT_, ParserSET_, ParserTABLE_, ParserTEMP_, ParserTEMPORARY_, ParserTHEN_, ParserTO_, ParserTRANSACTION_, ParserTRIGGER_, ParserUNION_, ParserUNIQUE_, ParserUPDATE_, ParserUSING_, ParserVACUUM_, ParserVALUES_, ParserVIEW_, ParserVIRTUAL_, ParserWHEN_, ParserWHERE_, ParserWITH_, ParserWITHOUT_, ParserFIRST_VALUE_, ParserOVER_, ParserPARTITION_, ParserRANGE_, ParserPRECEDING_, ParserUNBOUNDED_, ParserCURRENT_, ParserFOLLOWING_, ParserCUME_DIST_, ParserDENSE_RANK_, ParserLAG_, ParserLAST_VALUE_, ParserLEAD_, ParserNTH_VALUE_, ParserNTILE_, ParserPERCENT_RANK_, ParserRANK_, ParserROW_NUMBER_, ParserGENERATED_, ParserALWAYS_, ParserSTORED_, ParserTRUE_, ParserFALSE_, ParserWINDOW_, ParserNULLS_, ParserFIRST_, ParserLAST_, ParserFILTER_, ParserGROUPS_, ParserEXCLUDE_, ParserIDENTIFIER, ParserNUMERIC_LITERAL, ParserBIND_PARAMETER, ParserSTRING_LITERAL, ParserBLOB_LITERAL: 11059 p.SetState(894) 11060 p.GetErrorHandler().Sync(p) 11061 11062 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 109, p.GetParserRuleContext()) == 1 { 11063 { 11064 p.SetState(893) 11065 p.Match(ParserDISTINCT_) 11066 } 11067 11068 } 11069 { 11070 p.SetState(896) 11071 p.expr(0) 11072 } 11073 p.SetState(901) 11074 p.GetErrorHandler().Sync(p) 11075 _la = p.GetTokenStream().LA(1) 11076 11077 for _la == ParserCOMMA { 11078 { 11079 p.SetState(897) 11080 p.Match(ParserCOMMA) 11081 } 11082 { 11083 p.SetState(898) 11084 p.expr(0) 11085 } 11086 11087 p.SetState(903) 11088 p.GetErrorHandler().Sync(p) 11089 _la = p.GetTokenStream().LA(1) 11090 } 11091 11092 case ParserSTAR: 11093 { 11094 p.SetState(904) 11095 p.Match(ParserSTAR) 11096 } 11097 11098 case ParserCLOSE_PAR: 11099 11100 default: 11101 } 11102 { 11103 p.SetState(907) 11104 p.Match(ParserCLOSE_PAR) 11105 } 11106 p.SetState(909) 11107 p.GetErrorHandler().Sync(p) 11108 11109 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 112, p.GetParserRuleContext()) == 1 { 11110 { 11111 p.SetState(908) 11112 p.Filter_clause() 11113 } 11114 11115 } 11116 p.SetState(912) 11117 p.GetErrorHandler().Sync(p) 11118 11119 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 113, p.GetParserRuleContext()) == 1 { 11120 { 11121 p.SetState(911) 11122 p.Over_clause() 11123 } 11124 11125 } 11126 11127 case 6: 11128 { 11129 p.SetState(914) 11130 p.Match(ParserOPEN_PAR) 11131 } 11132 { 11133 p.SetState(915) 11134 p.expr(0) 11135 } 11136 p.SetState(920) 11137 p.GetErrorHandler().Sync(p) 11138 _la = p.GetTokenStream().LA(1) 11139 11140 for _la == ParserCOMMA { 11141 { 11142 p.SetState(916) 11143 p.Match(ParserCOMMA) 11144 } 11145 { 11146 p.SetState(917) 11147 p.expr(0) 11148 } 11149 11150 p.SetState(922) 11151 p.GetErrorHandler().Sync(p) 11152 _la = p.GetTokenStream().LA(1) 11153 } 11154 { 11155 p.SetState(923) 11156 p.Match(ParserCLOSE_PAR) 11157 } 11158 11159 case 7: 11160 { 11161 p.SetState(925) 11162 p.Match(ParserCAST_) 11163 } 11164 { 11165 p.SetState(926) 11166 p.Match(ParserOPEN_PAR) 11167 } 11168 { 11169 p.SetState(927) 11170 p.expr(0) 11171 } 11172 { 11173 p.SetState(928) 11174 p.Match(ParserAS_) 11175 } 11176 { 11177 p.SetState(929) 11178 p.Type_name() 11179 } 11180 { 11181 p.SetState(930) 11182 p.Match(ParserCLOSE_PAR) 11183 } 11184 11185 case 8: 11186 p.SetState(936) 11187 p.GetErrorHandler().Sync(p) 11188 _la = p.GetTokenStream().LA(1) 11189 11190 if _la == ParserEXISTS_ || _la == ParserNOT_ { 11191 p.SetState(933) 11192 p.GetErrorHandler().Sync(p) 11193 _la = p.GetTokenStream().LA(1) 11194 11195 if _la == ParserNOT_ { 11196 { 11197 p.SetState(932) 11198 p.Match(ParserNOT_) 11199 } 11200 11201 } 11202 { 11203 p.SetState(935) 11204 p.Match(ParserEXISTS_) 11205 } 11206 11207 } 11208 { 11209 p.SetState(938) 11210 p.Match(ParserOPEN_PAR) 11211 } 11212 { 11213 p.SetState(939) 11214 p.Select_stmt() 11215 } 11216 { 11217 p.SetState(940) 11218 p.Match(ParserCLOSE_PAR) 11219 } 11220 11221 case 9: 11222 { 11223 p.SetState(942) 11224 p.Match(ParserCASE_) 11225 } 11226 p.SetState(944) 11227 p.GetErrorHandler().Sync(p) 11228 11229 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 117, p.GetParserRuleContext()) == 1 { 11230 { 11231 p.SetState(943) 11232 p.expr(0) 11233 } 11234 11235 } 11236 p.SetState(951) 11237 p.GetErrorHandler().Sync(p) 11238 _la = p.GetTokenStream().LA(1) 11239 11240 for ok := true; ok; ok = _la == ParserWHEN_ { 11241 { 11242 p.SetState(946) 11243 p.Match(ParserWHEN_) 11244 } 11245 { 11246 p.SetState(947) 11247 p.expr(0) 11248 } 11249 { 11250 p.SetState(948) 11251 p.Match(ParserTHEN_) 11252 } 11253 { 11254 p.SetState(949) 11255 p.expr(0) 11256 } 11257 11258 p.SetState(953) 11259 p.GetErrorHandler().Sync(p) 11260 _la = p.GetTokenStream().LA(1) 11261 } 11262 p.SetState(957) 11263 p.GetErrorHandler().Sync(p) 11264 _la = p.GetTokenStream().LA(1) 11265 11266 if _la == ParserELSE_ { 11267 { 11268 p.SetState(955) 11269 p.Match(ParserELSE_) 11270 } 11271 { 11272 p.SetState(956) 11273 p.expr(0) 11274 } 11275 11276 } 11277 { 11278 p.SetState(959) 11279 p.Match(ParserEND_) 11280 } 11281 11282 case 10: 11283 { 11284 p.SetState(961) 11285 p.Raise_function() 11286 } 11287 11288 } 11289 p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) 11290 p.SetState(1083) 11291 p.GetErrorHandler().Sync(p) 11292 _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 136, p.GetParserRuleContext()) 11293 11294 for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { 11295 if _alt == 1 { 11296 if p.GetParseListeners() != nil { 11297 p.TriggerExitRuleEvent() 11298 } 11299 _prevctx = localctx 11300 p.SetState(1081) 11301 p.GetErrorHandler().Sync(p) 11302 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 135, p.GetParserRuleContext()) { 11303 case 1: 11304 localctx = NewExprContext(p, _parentctx, _parentState) 11305 p.PushNewRecursionContext(localctx, _startState, ParserRULE_expr) 11306 p.SetState(964) 11307 11308 if !(p.Precpred(p.GetParserRuleContext(), 20)) { 11309 panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 20)", "")) 11310 } 11311 { 11312 p.SetState(965) 11313 p.Match(ParserPIPE2) 11314 } 11315 { 11316 p.SetState(966) 11317 p.expr(21) 11318 } 11319 11320 case 2: 11321 localctx = NewExprContext(p, _parentctx, _parentState) 11322 p.PushNewRecursionContext(localctx, _startState, ParserRULE_expr) 11323 p.SetState(967) 11324 11325 if !(p.Precpred(p.GetParserRuleContext(), 19)) { 11326 panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 19)", "")) 11327 } 11328 { 11329 p.SetState(968) 11330 _la = p.GetTokenStream().LA(1) 11331 11332 if !(((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<ParserSTAR)|(1<<ParserDIV)|(1<<ParserMOD))) != 0) { 11333 p.GetErrorHandler().RecoverInline(p) 11334 } else { 11335 p.GetErrorHandler().ReportMatch(p) 11336 p.Consume() 11337 } 11338 } 11339 { 11340 p.SetState(969) 11341 p.expr(20) 11342 } 11343 11344 case 3: 11345 localctx = NewExprContext(p, _parentctx, _parentState) 11346 p.PushNewRecursionContext(localctx, _startState, ParserRULE_expr) 11347 p.SetState(970) 11348 11349 if !(p.Precpred(p.GetParserRuleContext(), 18)) { 11350 panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 18)", "")) 11351 } 11352 { 11353 p.SetState(971) 11354 _la = p.GetTokenStream().LA(1) 11355 11356 if !(_la == ParserPLUS || _la == ParserMINUS) { 11357 p.GetErrorHandler().RecoverInline(p) 11358 } else { 11359 p.GetErrorHandler().ReportMatch(p) 11360 p.Consume() 11361 } 11362 } 11363 { 11364 p.SetState(972) 11365 p.expr(19) 11366 } 11367 11368 case 4: 11369 localctx = NewExprContext(p, _parentctx, _parentState) 11370 p.PushNewRecursionContext(localctx, _startState, ParserRULE_expr) 11371 p.SetState(973) 11372 11373 if !(p.Precpred(p.GetParserRuleContext(), 17)) { 11374 panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 17)", "")) 11375 } 11376 { 11377 p.SetState(974) 11378 _la = p.GetTokenStream().LA(1) 11379 11380 if !(((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<ParserLT2)|(1<<ParserGT2)|(1<<ParserAMP)|(1<<ParserPIPE))) != 0) { 11381 p.GetErrorHandler().RecoverInline(p) 11382 } else { 11383 p.GetErrorHandler().ReportMatch(p) 11384 p.Consume() 11385 } 11386 } 11387 { 11388 p.SetState(975) 11389 p.expr(18) 11390 } 11391 11392 case 5: 11393 localctx = NewExprContext(p, _parentctx, _parentState) 11394 p.PushNewRecursionContext(localctx, _startState, ParserRULE_expr) 11395 p.SetState(976) 11396 11397 if !(p.Precpred(p.GetParserRuleContext(), 16)) { 11398 panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 16)", "")) 11399 } 11400 { 11401 p.SetState(977) 11402 _la = p.GetTokenStream().LA(1) 11403 11404 if !(((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<ParserLT)|(1<<ParserLT_EQ)|(1<<ParserGT)|(1<<ParserGT_EQ))) != 0) { 11405 p.GetErrorHandler().RecoverInline(p) 11406 } else { 11407 p.GetErrorHandler().ReportMatch(p) 11408 p.Consume() 11409 } 11410 } 11411 { 11412 p.SetState(978) 11413 p.expr(17) 11414 } 11415 11416 case 6: 11417 localctx = NewExprContext(p, _parentctx, _parentState) 11418 p.PushNewRecursionContext(localctx, _startState, ParserRULE_expr) 11419 p.SetState(979) 11420 11421 if !(p.Precpred(p.GetParserRuleContext(), 15)) { 11422 panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 15)", "")) 11423 } 11424 p.SetState(992) 11425 p.GetErrorHandler().Sync(p) 11426 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 121, p.GetParserRuleContext()) { 11427 case 1: 11428 { 11429 p.SetState(980) 11430 p.Match(ParserASSIGN) 11431 } 11432 11433 case 2: 11434 { 11435 p.SetState(981) 11436 p.Match(ParserEQ) 11437 } 11438 11439 case 3: 11440 { 11441 p.SetState(982) 11442 p.Match(ParserNOT_EQ1) 11443 } 11444 11445 case 4: 11446 { 11447 p.SetState(983) 11448 p.Match(ParserNOT_EQ2) 11449 } 11450 11451 case 5: 11452 { 11453 p.SetState(984) 11454 p.Match(ParserIS_) 11455 } 11456 11457 case 6: 11458 { 11459 p.SetState(985) 11460 p.Match(ParserIS_) 11461 } 11462 { 11463 p.SetState(986) 11464 p.Match(ParserNOT_) 11465 } 11466 11467 case 7: 11468 { 11469 p.SetState(987) 11470 p.Match(ParserIN_) 11471 } 11472 11473 case 8: 11474 { 11475 p.SetState(988) 11476 p.Match(ParserLIKE_) 11477 } 11478 11479 case 9: 11480 { 11481 p.SetState(989) 11482 p.Match(ParserGLOB_) 11483 } 11484 11485 case 10: 11486 { 11487 p.SetState(990) 11488 p.Match(ParserMATCH_) 11489 } 11490 11491 case 11: 11492 { 11493 p.SetState(991) 11494 p.Match(ParserREGEXP_) 11495 } 11496 11497 } 11498 { 11499 p.SetState(994) 11500 p.expr(16) 11501 } 11502 11503 case 7: 11504 localctx = NewExprContext(p, _parentctx, _parentState) 11505 p.PushNewRecursionContext(localctx, _startState, ParserRULE_expr) 11506 p.SetState(995) 11507 11508 if !(p.Precpred(p.GetParserRuleContext(), 14)) { 11509 panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 14)", "")) 11510 } 11511 { 11512 p.SetState(996) 11513 p.Match(ParserAND_) 11514 } 11515 { 11516 p.SetState(997) 11517 p.expr(15) 11518 } 11519 11520 case 8: 11521 localctx = NewExprContext(p, _parentctx, _parentState) 11522 p.PushNewRecursionContext(localctx, _startState, ParserRULE_expr) 11523 p.SetState(998) 11524 11525 if !(p.Precpred(p.GetParserRuleContext(), 13)) { 11526 panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 13)", "")) 11527 } 11528 { 11529 p.SetState(999) 11530 p.Match(ParserOR_) 11531 } 11532 { 11533 p.SetState(1000) 11534 p.expr(14) 11535 } 11536 11537 case 9: 11538 localctx = NewExprContext(p, _parentctx, _parentState) 11539 p.PushNewRecursionContext(localctx, _startState, ParserRULE_expr) 11540 p.SetState(1001) 11541 11542 if !(p.Precpred(p.GetParserRuleContext(), 6)) { 11543 panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 6)", "")) 11544 } 11545 { 11546 p.SetState(1002) 11547 p.Match(ParserIS_) 11548 } 11549 p.SetState(1004) 11550 p.GetErrorHandler().Sync(p) 11551 11552 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 122, p.GetParserRuleContext()) == 1 { 11553 { 11554 p.SetState(1003) 11555 p.Match(ParserNOT_) 11556 } 11557 11558 } 11559 { 11560 p.SetState(1006) 11561 p.expr(7) 11562 } 11563 11564 case 10: 11565 localctx = NewExprContext(p, _parentctx, _parentState) 11566 p.PushNewRecursionContext(localctx, _startState, ParserRULE_expr) 11567 p.SetState(1007) 11568 11569 if !(p.Precpred(p.GetParserRuleContext(), 5)) { 11570 panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", "")) 11571 } 11572 p.SetState(1009) 11573 p.GetErrorHandler().Sync(p) 11574 _la = p.GetTokenStream().LA(1) 11575 11576 if _la == ParserNOT_ { 11577 { 11578 p.SetState(1008) 11579 p.Match(ParserNOT_) 11580 } 11581 11582 } 11583 { 11584 p.SetState(1011) 11585 p.Match(ParserBETWEEN_) 11586 } 11587 { 11588 p.SetState(1012) 11589 p.expr(0) 11590 } 11591 { 11592 p.SetState(1013) 11593 p.Match(ParserAND_) 11594 } 11595 { 11596 p.SetState(1014) 11597 p.expr(6) 11598 } 11599 11600 case 11: 11601 localctx = NewExprContext(p, _parentctx, _parentState) 11602 p.PushNewRecursionContext(localctx, _startState, ParserRULE_expr) 11603 p.SetState(1016) 11604 11605 if !(p.Precpred(p.GetParserRuleContext(), 9)) { 11606 panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 9)", "")) 11607 } 11608 { 11609 p.SetState(1017) 11610 p.Match(ParserCOLLATE_) 11611 } 11612 { 11613 p.SetState(1018) 11614 p.Collation_name() 11615 } 11616 11617 case 12: 11618 localctx = NewExprContext(p, _parentctx, _parentState) 11619 p.PushNewRecursionContext(localctx, _startState, ParserRULE_expr) 11620 p.SetState(1019) 11621 11622 if !(p.Precpred(p.GetParserRuleContext(), 8)) { 11623 panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 8)", "")) 11624 } 11625 p.SetState(1021) 11626 p.GetErrorHandler().Sync(p) 11627 _la = p.GetTokenStream().LA(1) 11628 11629 if _la == ParserNOT_ { 11630 { 11631 p.SetState(1020) 11632 p.Match(ParserNOT_) 11633 } 11634 11635 } 11636 { 11637 p.SetState(1023) 11638 _la = p.GetTokenStream().LA(1) 11639 11640 if !((((_la-77)&-(0x1f+1)) == 0 && ((1<<uint((_la-77)))&((1<<(ParserGLOB_-77))|(1<<(ParserLIKE_-77))|(1<<(ParserMATCH_-77)))) != 0) || _la == ParserREGEXP_) { 11641 p.GetErrorHandler().RecoverInline(p) 11642 } else { 11643 p.GetErrorHandler().ReportMatch(p) 11644 p.Consume() 11645 } 11646 } 11647 { 11648 p.SetState(1024) 11649 p.expr(0) 11650 } 11651 p.SetState(1027) 11652 p.GetErrorHandler().Sync(p) 11653 11654 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 125, p.GetParserRuleContext()) == 1 { 11655 { 11656 p.SetState(1025) 11657 p.Match(ParserESCAPE_) 11658 } 11659 { 11660 p.SetState(1026) 11661 p.expr(0) 11662 } 11663 11664 } 11665 11666 case 13: 11667 localctx = NewExprContext(p, _parentctx, _parentState) 11668 p.PushNewRecursionContext(localctx, _startState, ParserRULE_expr) 11669 p.SetState(1029) 11670 11671 if !(p.Precpred(p.GetParserRuleContext(), 7)) { 11672 panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 7)", "")) 11673 } 11674 p.SetState(1034) 11675 p.GetErrorHandler().Sync(p) 11676 11677 switch p.GetTokenStream().LA(1) { 11678 case ParserISNULL_: 11679 { 11680 p.SetState(1030) 11681 p.Match(ParserISNULL_) 11682 } 11683 11684 case ParserNOTNULL_: 11685 { 11686 p.SetState(1031) 11687 p.Match(ParserNOTNULL_) 11688 } 11689 11690 case ParserNOT_: 11691 { 11692 p.SetState(1032) 11693 p.Match(ParserNOT_) 11694 } 11695 { 11696 p.SetState(1033) 11697 p.Match(ParserNULL_) 11698 } 11699 11700 default: 11701 panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) 11702 } 11703 11704 case 14: 11705 localctx = NewExprContext(p, _parentctx, _parentState) 11706 p.PushNewRecursionContext(localctx, _startState, ParserRULE_expr) 11707 p.SetState(1036) 11708 11709 if !(p.Precpred(p.GetParserRuleContext(), 4)) { 11710 panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", "")) 11711 } 11712 p.SetState(1038) 11713 p.GetErrorHandler().Sync(p) 11714 _la = p.GetTokenStream().LA(1) 11715 11716 if _la == ParserNOT_ { 11717 { 11718 p.SetState(1037) 11719 p.Match(ParserNOT_) 11720 } 11721 11722 } 11723 { 11724 p.SetState(1040) 11725 p.Match(ParserIN_) 11726 } 11727 p.SetState(1079) 11728 p.GetErrorHandler().Sync(p) 11729 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 134, p.GetParserRuleContext()) { 11730 case 1: 11731 { 11732 p.SetState(1041) 11733 p.Match(ParserOPEN_PAR) 11734 } 11735 p.SetState(1051) 11736 p.GetErrorHandler().Sync(p) 11737 11738 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 129, p.GetParserRuleContext()) == 1 { 11739 { 11740 p.SetState(1042) 11741 p.Select_stmt() 11742 } 11743 11744 } else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 129, p.GetParserRuleContext()) == 2 { 11745 { 11746 p.SetState(1043) 11747 p.expr(0) 11748 } 11749 p.SetState(1048) 11750 p.GetErrorHandler().Sync(p) 11751 _la = p.GetTokenStream().LA(1) 11752 11753 for _la == ParserCOMMA { 11754 { 11755 p.SetState(1044) 11756 p.Match(ParserCOMMA) 11757 } 11758 { 11759 p.SetState(1045) 11760 p.expr(0) 11761 } 11762 11763 p.SetState(1050) 11764 p.GetErrorHandler().Sync(p) 11765 _la = p.GetTokenStream().LA(1) 11766 } 11767 11768 } 11769 { 11770 p.SetState(1053) 11771 p.Match(ParserCLOSE_PAR) 11772 } 11773 11774 case 2: 11775 p.SetState(1057) 11776 p.GetErrorHandler().Sync(p) 11777 11778 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 130, p.GetParserRuleContext()) == 1 { 11779 { 11780 p.SetState(1054) 11781 p.Schema_name() 11782 } 11783 { 11784 p.SetState(1055) 11785 p.Match(ParserDOT) 11786 } 11787 11788 } 11789 { 11790 p.SetState(1059) 11791 p.Table_name() 11792 } 11793 11794 case 3: 11795 p.SetState(1063) 11796 p.GetErrorHandler().Sync(p) 11797 11798 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 131, p.GetParserRuleContext()) == 1 { 11799 { 11800 p.SetState(1060) 11801 p.Schema_name() 11802 } 11803 { 11804 p.SetState(1061) 11805 p.Match(ParserDOT) 11806 } 11807 11808 } 11809 { 11810 p.SetState(1065) 11811 p.Table_function_name() 11812 } 11813 { 11814 p.SetState(1066) 11815 p.Match(ParserOPEN_PAR) 11816 } 11817 p.SetState(1075) 11818 p.GetErrorHandler().Sync(p) 11819 _la = p.GetTokenStream().LA(1) 11820 11821 if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<ParserOPEN_PAR)|(1<<ParserPLUS)|(1<<ParserMINUS)|(1<<ParserTILDE)|(1<<ParserABORT_)|(1<<ParserACTION_)|(1<<ParserADD_)|(1<<ParserAFTER_)|(1<<ParserALL_)|(1<<ParserALTER_)|(1<<ParserANALYZE_))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(ParserAND_-32))|(1<<(ParserAS_-32))|(1<<(ParserASC_-32))|(1<<(ParserATTACH_-32))|(1<<(ParserAUTOINCREMENT_-32))|(1<<(ParserBEFORE_-32))|(1<<(ParserBEGIN_-32))|(1<<(ParserBETWEEN_-32))|(1<<(ParserBY_-32))|(1<<(ParserCASCADE_-32))|(1<<(ParserCASE_-32))|(1<<(ParserCAST_-32))|(1<<(ParserCHECK_-32))|(1<<(ParserCOLLATE_-32))|(1<<(ParserCOLUMN_-32))|(1<<(ParserCOMMIT_-32))|(1<<(ParserCONFLICT_-32))|(1<<(ParserCONSTRAINT_-32))|(1<<(ParserCREATE_-32))|(1<<(ParserCROSS_-32))|(1<<(ParserCURRENT_DATE_-32))|(1<<(ParserCURRENT_TIME_-32))|(1<<(ParserCURRENT_TIMESTAMP_-32))|(1<<(ParserDATABASE_-32))|(1<<(ParserDEFAULT_-32))|(1<<(ParserDEFERRABLE_-32))|(1<<(ParserDEFERRED_-32))|(1<<(ParserDELETE_-32))|(1<<(ParserDESC_-32))|(1<<(ParserDETACH_-32))|(1<<(ParserDISTINCT_-32))|(1<<(ParserDROP_-32)))) != 0) || (((_la-64)&-(0x1f+1)) == 0 && ((1<<uint((_la-64)))&((1<<(ParserEACH_-64))|(1<<(ParserELSE_-64))|(1<<(ParserEND_-64))|(1<<(ParserESCAPE_-64))|(1<<(ParserEXCEPT_-64))|(1<<(ParserEXCLUSIVE_-64))|(1<<(ParserEXISTS_-64))|(1<<(ParserEXPLAIN_-64))|(1<<(ParserFAIL_-64))|(1<<(ParserFOR_-64))|(1<<(ParserFOREIGN_-64))|(1<<(ParserFROM_-64))|(1<<(ParserFULL_-64))|(1<<(ParserGLOB_-64))|(1<<(ParserGROUP_-64))|(1<<(ParserHAVING_-64))|(1<<(ParserIF_-64))|(1<<(ParserIGNORE_-64))|(1<<(ParserIMMEDIATE_-64))|(1<<(ParserIN_-64))|(1<<(ParserINDEX_-64))|(1<<(ParserINDEXED_-64))|(1<<(ParserINITIALLY_-64))|(1<<(ParserINNER_-64))|(1<<(ParserINSERT_-64))|(1<<(ParserINSTEAD_-64))|(1<<(ParserINTERSECT_-64))|(1<<(ParserINTO_-64))|(1<<(ParserIS_-64))|(1<<(ParserISNULL_-64))|(1<<(ParserJOIN_-64))|(1<<(ParserKEY_-64)))) != 0) || (((_la-96)&-(0x1f+1)) == 0 && ((1<<uint((_la-96)))&((1<<(ParserLEFT_-96))|(1<<(ParserLIKE_-96))|(1<<(ParserLIMIT_-96))|(1<<(ParserMATCH_-96))|(1<<(ParserNATURAL_-96))|(1<<(ParserNO_-96))|(1<<(ParserNOT_-96))|(1<<(ParserNOTNULL_-96))|(1<<(ParserNULL_-96))|(1<<(ParserOF_-96))|(1<<(ParserOFFSET_-96))|(1<<(ParserON_-96))|(1<<(ParserOR_-96))|(1<<(ParserORDER_-96))|(1<<(ParserOUTER_-96))|(1<<(ParserPLAN_-96))|(1<<(ParserPRAGMA_-96))|(1<<(ParserPRIMARY_-96))|(1<<(ParserQUERY_-96))|(1<<(ParserRAISE_-96))|(1<<(ParserRECURSIVE_-96))|(1<<(ParserREFERENCES_-96))|(1<<(ParserREGEXP_-96))|(1<<(ParserREINDEX_-96))|(1<<(ParserRELEASE_-96))|(1<<(ParserRENAME_-96))|(1<<(ParserREPLACE_-96))|(1<<(ParserRESTRICT_-96))|(1<<(ParserRIGHT_-96))|(1<<(ParserROLLBACK_-96))|(1<<(ParserROW_-96)))) != 0) || (((_la-128)&-(0x1f+1)) == 0 && ((1<<uint((_la-128)))&((1<<(ParserROWS_-128))|(1<<(ParserSAVEPOINT_-128))|(1<<(ParserSELECT_-128))|(1<<(ParserSET_-128))|(1<<(ParserTABLE_-128))|(1<<(ParserTEMP_-128))|(1<<(ParserTEMPORARY_-128))|(1<<(ParserTHEN_-128))|(1<<(ParserTO_-128))|(1<<(ParserTRANSACTION_-128))|(1<<(ParserTRIGGER_-128))|(1<<(ParserUNION_-128))|(1<<(ParserUNIQUE_-128))|(1<<(ParserUPDATE_-128))|(1<<(ParserUSING_-128))|(1<<(ParserVACUUM_-128))|(1<<(ParserVALUES_-128))|(1<<(ParserVIEW_-128))|(1<<(ParserVIRTUAL_-128))|(1<<(ParserWHEN_-128))|(1<<(ParserWHERE_-128))|(1<<(ParserWITH_-128))|(1<<(ParserWITHOUT_-128))|(1<<(ParserFIRST_VALUE_-128))|(1<<(ParserOVER_-128))|(1<<(ParserPARTITION_-128))|(1<<(ParserRANGE_-128))|(1<<(ParserPRECEDING_-128))|(1<<(ParserUNBOUNDED_-128))|(1<<(ParserCURRENT_-128))|(1<<(ParserFOLLOWING_-128))|(1<<(ParserCUME_DIST_-128)))) != 0) || (((_la-160)&-(0x1f+1)) == 0 && ((1<<uint((_la-160)))&((1<<(ParserDENSE_RANK_-160))|(1<<(ParserLAG_-160))|(1<<(ParserLAST_VALUE_-160))|(1<<(ParserLEAD_-160))|(1<<(ParserNTH_VALUE_-160))|(1<<(ParserNTILE_-160))|(1<<(ParserPERCENT_RANK_-160))|(1<<(ParserRANK_-160))|(1<<(ParserROW_NUMBER_-160))|(1<<(ParserGENERATED_-160))|(1<<(ParserALWAYS_-160))|(1<<(ParserSTORED_-160))|(1<<(ParserTRUE_-160))|(1<<(ParserFALSE_-160))|(1<<(ParserWINDOW_-160))|(1<<(ParserNULLS_-160))|(1<<(ParserFIRST_-160))|(1<<(ParserLAST_-160))|(1<<(ParserFILTER_-160))|(1<<(ParserGROUPS_-160))|(1<<(ParserEXCLUDE_-160))|(1<<(ParserIDENTIFIER-160))|(1<<(ParserNUMERIC_LITERAL-160))|(1<<(ParserBIND_PARAMETER-160))|(1<<(ParserSTRING_LITERAL-160))|(1<<(ParserBLOB_LITERAL-160)))) != 0) { 11822 { 11823 p.SetState(1067) 11824 p.expr(0) 11825 } 11826 p.SetState(1072) 11827 p.GetErrorHandler().Sync(p) 11828 _la = p.GetTokenStream().LA(1) 11829 11830 for _la == ParserCOMMA { 11831 { 11832 p.SetState(1068) 11833 p.Match(ParserCOMMA) 11834 } 11835 { 11836 p.SetState(1069) 11837 p.expr(0) 11838 } 11839 11840 p.SetState(1074) 11841 p.GetErrorHandler().Sync(p) 11842 _la = p.GetTokenStream().LA(1) 11843 } 11844 11845 } 11846 { 11847 p.SetState(1077) 11848 p.Match(ParserCLOSE_PAR) 11849 } 11850 11851 } 11852 11853 } 11854 11855 } 11856 p.SetState(1085) 11857 p.GetErrorHandler().Sync(p) 11858 _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 136, p.GetParserRuleContext()) 11859 } 11860 11861 return localctx 11862 } 11863 11864 // IRaise_functionContext is an interface to support dynamic dispatch. 11865 type IRaise_functionContext interface { 11866 antlr.ParserRuleContext 11867 11868 // GetParser returns the parser. 11869 GetParser() antlr.Parser 11870 11871 // IsRaise_functionContext differentiates from other interfaces. 11872 IsRaise_functionContext() 11873 } 11874 11875 type Raise_functionContext struct { 11876 *antlr.BaseParserRuleContext 11877 parser antlr.Parser 11878 } 11879 11880 func NewEmptyRaise_functionContext() *Raise_functionContext { 11881 var p = new(Raise_functionContext) 11882 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 11883 p.RuleIndex = ParserRULE_raise_function 11884 return p 11885 } 11886 11887 func (*Raise_functionContext) IsRaise_functionContext() {} 11888 11889 func NewRaise_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Raise_functionContext { 11890 var p = new(Raise_functionContext) 11891 11892 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 11893 11894 p.parser = parser 11895 p.RuleIndex = ParserRULE_raise_function 11896 11897 return p 11898 } 11899 11900 func (s *Raise_functionContext) GetParser() antlr.Parser { return s.parser } 11901 11902 func (s *Raise_functionContext) RAISE_() antlr.TerminalNode { 11903 return s.GetToken(ParserRAISE_, 0) 11904 } 11905 11906 func (s *Raise_functionContext) OPEN_PAR() antlr.TerminalNode { 11907 return s.GetToken(ParserOPEN_PAR, 0) 11908 } 11909 11910 func (s *Raise_functionContext) CLOSE_PAR() antlr.TerminalNode { 11911 return s.GetToken(ParserCLOSE_PAR, 0) 11912 } 11913 11914 func (s *Raise_functionContext) IGNORE_() antlr.TerminalNode { 11915 return s.GetToken(ParserIGNORE_, 0) 11916 } 11917 11918 func (s *Raise_functionContext) COMMA() antlr.TerminalNode { 11919 return s.GetToken(ParserCOMMA, 0) 11920 } 11921 11922 func (s *Raise_functionContext) Error_message() IError_messageContext { 11923 var t antlr.RuleContext 11924 for _, ctx := range s.GetChildren() { 11925 if _, ok := ctx.(IError_messageContext); ok { 11926 t = ctx.(antlr.RuleContext) 11927 break 11928 } 11929 } 11930 11931 if t == nil { 11932 return nil 11933 } 11934 11935 return t.(IError_messageContext) 11936 } 11937 11938 func (s *Raise_functionContext) ROLLBACK_() antlr.TerminalNode { 11939 return s.GetToken(ParserROLLBACK_, 0) 11940 } 11941 11942 func (s *Raise_functionContext) ABORT_() antlr.TerminalNode { 11943 return s.GetToken(ParserABORT_, 0) 11944 } 11945 11946 func (s *Raise_functionContext) FAIL_() antlr.TerminalNode { 11947 return s.GetToken(ParserFAIL_, 0) 11948 } 11949 11950 func (s *Raise_functionContext) GetRuleContext() antlr.RuleContext { 11951 return s 11952 } 11953 11954 func (s *Raise_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 11955 return antlr.TreesStringTree(s, ruleNames, recog) 11956 } 11957 11958 func (s *Raise_functionContext) EnterRule(listener antlr.ParseTreeListener) { 11959 if listenerT, ok := listener.(ParserListener); ok { 11960 listenerT.EnterRaise_function(s) 11961 } 11962 } 11963 11964 func (s *Raise_functionContext) ExitRule(listener antlr.ParseTreeListener) { 11965 if listenerT, ok := listener.(ParserListener); ok { 11966 listenerT.ExitRaise_function(s) 11967 } 11968 } 11969 11970 func (s *Raise_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 11971 switch t := visitor.(type) { 11972 case ParserVisitor: 11973 return t.VisitRaise_function(s) 11974 11975 default: 11976 return t.VisitChildren(s) 11977 } 11978 } 11979 11980 func (p *Parser) Raise_function() (localctx IRaise_functionContext) { 11981 this := p 11982 _ = this 11983 11984 localctx = NewRaise_functionContext(p, p.GetParserRuleContext(), p.GetState()) 11985 p.EnterRule(localctx, 66, ParserRULE_raise_function) 11986 var _la int 11987 11988 defer func() { 11989 p.ExitRule() 11990 }() 11991 11992 defer func() { 11993 if err := recover(); err != nil { 11994 if v, ok := err.(antlr.RecognitionException); ok { 11995 localctx.SetException(v) 11996 p.GetErrorHandler().ReportError(p, v) 11997 p.GetErrorHandler().Recover(p, v) 11998 } else { 11999 panic(err) 12000 } 12001 } 12002 }() 12003 12004 p.EnterOuterAlt(localctx, 1) 12005 { 12006 p.SetState(1086) 12007 p.Match(ParserRAISE_) 12008 } 12009 { 12010 p.SetState(1087) 12011 p.Match(ParserOPEN_PAR) 12012 } 12013 p.SetState(1092) 12014 p.GetErrorHandler().Sync(p) 12015 12016 switch p.GetTokenStream().LA(1) { 12017 case ParserIGNORE_: 12018 { 12019 p.SetState(1088) 12020 p.Match(ParserIGNORE_) 12021 } 12022 12023 case ParserABORT_, ParserFAIL_, ParserROLLBACK_: 12024 { 12025 p.SetState(1089) 12026 _la = p.GetTokenStream().LA(1) 12027 12028 if !(_la == ParserABORT_ || _la == ParserFAIL_ || _la == ParserROLLBACK_) { 12029 p.GetErrorHandler().RecoverInline(p) 12030 } else { 12031 p.GetErrorHandler().ReportMatch(p) 12032 p.Consume() 12033 } 12034 } 12035 { 12036 p.SetState(1090) 12037 p.Match(ParserCOMMA) 12038 } 12039 { 12040 p.SetState(1091) 12041 p.Error_message() 12042 } 12043 12044 default: 12045 panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) 12046 } 12047 { 12048 p.SetState(1094) 12049 p.Match(ParserCLOSE_PAR) 12050 } 12051 12052 return localctx 12053 } 12054 12055 // ILiteral_valueContext is an interface to support dynamic dispatch. 12056 type ILiteral_valueContext interface { 12057 antlr.ParserRuleContext 12058 12059 // GetParser returns the parser. 12060 GetParser() antlr.Parser 12061 12062 // IsLiteral_valueContext differentiates from other interfaces. 12063 IsLiteral_valueContext() 12064 } 12065 12066 type Literal_valueContext struct { 12067 *antlr.BaseParserRuleContext 12068 parser antlr.Parser 12069 } 12070 12071 func NewEmptyLiteral_valueContext() *Literal_valueContext { 12072 var p = new(Literal_valueContext) 12073 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 12074 p.RuleIndex = ParserRULE_literal_value 12075 return p 12076 } 12077 12078 func (*Literal_valueContext) IsLiteral_valueContext() {} 12079 12080 func NewLiteral_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Literal_valueContext { 12081 var p = new(Literal_valueContext) 12082 12083 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 12084 12085 p.parser = parser 12086 p.RuleIndex = ParserRULE_literal_value 12087 12088 return p 12089 } 12090 12091 func (s *Literal_valueContext) GetParser() antlr.Parser { return s.parser } 12092 12093 func (s *Literal_valueContext) NUMERIC_LITERAL() antlr.TerminalNode { 12094 return s.GetToken(ParserNUMERIC_LITERAL, 0) 12095 } 12096 12097 func (s *Literal_valueContext) STRING_LITERAL() antlr.TerminalNode { 12098 return s.GetToken(ParserSTRING_LITERAL, 0) 12099 } 12100 12101 func (s *Literal_valueContext) BLOB_LITERAL() antlr.TerminalNode { 12102 return s.GetToken(ParserBLOB_LITERAL, 0) 12103 } 12104 12105 func (s *Literal_valueContext) NULL_() antlr.TerminalNode { 12106 return s.GetToken(ParserNULL_, 0) 12107 } 12108 12109 func (s *Literal_valueContext) TRUE_() antlr.TerminalNode { 12110 return s.GetToken(ParserTRUE_, 0) 12111 } 12112 12113 func (s *Literal_valueContext) FALSE_() antlr.TerminalNode { 12114 return s.GetToken(ParserFALSE_, 0) 12115 } 12116 12117 func (s *Literal_valueContext) CURRENT_TIME_() antlr.TerminalNode { 12118 return s.GetToken(ParserCURRENT_TIME_, 0) 12119 } 12120 12121 func (s *Literal_valueContext) CURRENT_DATE_() antlr.TerminalNode { 12122 return s.GetToken(ParserCURRENT_DATE_, 0) 12123 } 12124 12125 func (s *Literal_valueContext) CURRENT_TIMESTAMP_() antlr.TerminalNode { 12126 return s.GetToken(ParserCURRENT_TIMESTAMP_, 0) 12127 } 12128 12129 func (s *Literal_valueContext) GetRuleContext() antlr.RuleContext { 12130 return s 12131 } 12132 12133 func (s *Literal_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 12134 return antlr.TreesStringTree(s, ruleNames, recog) 12135 } 12136 12137 func (s *Literal_valueContext) EnterRule(listener antlr.ParseTreeListener) { 12138 if listenerT, ok := listener.(ParserListener); ok { 12139 listenerT.EnterLiteral_value(s) 12140 } 12141 } 12142 12143 func (s *Literal_valueContext) ExitRule(listener antlr.ParseTreeListener) { 12144 if listenerT, ok := listener.(ParserListener); ok { 12145 listenerT.ExitLiteral_value(s) 12146 } 12147 } 12148 12149 func (s *Literal_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 12150 switch t := visitor.(type) { 12151 case ParserVisitor: 12152 return t.VisitLiteral_value(s) 12153 12154 default: 12155 return t.VisitChildren(s) 12156 } 12157 } 12158 12159 func (p *Parser) Literal_value() (localctx ILiteral_valueContext) { 12160 this := p 12161 _ = this 12162 12163 localctx = NewLiteral_valueContext(p, p.GetParserRuleContext(), p.GetState()) 12164 p.EnterRule(localctx, 68, ParserRULE_literal_value) 12165 var _la int 12166 12167 defer func() { 12168 p.ExitRule() 12169 }() 12170 12171 defer func() { 12172 if err := recover(); err != nil { 12173 if v, ok := err.(antlr.RecognitionException); ok { 12174 localctx.SetException(v) 12175 p.GetErrorHandler().ReportError(p, v) 12176 p.GetErrorHandler().Recover(p, v) 12177 } else { 12178 panic(err) 12179 } 12180 } 12181 }() 12182 12183 p.EnterOuterAlt(localctx, 1) 12184 { 12185 p.SetState(1096) 12186 _la = p.GetTokenStream().LA(1) 12187 12188 if !((((_la-52)&-(0x1f+1)) == 0 && ((1<<uint((_la-52)))&((1<<(ParserCURRENT_DATE_-52))|(1<<(ParserCURRENT_TIME_-52))|(1<<(ParserCURRENT_TIMESTAMP_-52)))) != 0) || _la == ParserNULL_ || (((_la-172)&-(0x1f+1)) == 0 && ((1<<uint((_la-172)))&((1<<(ParserTRUE_-172))|(1<<(ParserFALSE_-172))|(1<<(ParserNUMERIC_LITERAL-172))|(1<<(ParserSTRING_LITERAL-172))|(1<<(ParserBLOB_LITERAL-172)))) != 0)) { 12189 p.GetErrorHandler().RecoverInline(p) 12190 } else { 12191 p.GetErrorHandler().ReportMatch(p) 12192 p.Consume() 12193 } 12194 } 12195 12196 return localctx 12197 } 12198 12199 // IInsert_stmtContext is an interface to support dynamic dispatch. 12200 type IInsert_stmtContext interface { 12201 antlr.ParserRuleContext 12202 12203 // GetParser returns the parser. 12204 GetParser() antlr.Parser 12205 12206 // IsInsert_stmtContext differentiates from other interfaces. 12207 IsInsert_stmtContext() 12208 } 12209 12210 type Insert_stmtContext struct { 12211 *antlr.BaseParserRuleContext 12212 parser antlr.Parser 12213 } 12214 12215 func NewEmptyInsert_stmtContext() *Insert_stmtContext { 12216 var p = new(Insert_stmtContext) 12217 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 12218 p.RuleIndex = ParserRULE_insert_stmt 12219 return p 12220 } 12221 12222 func (*Insert_stmtContext) IsInsert_stmtContext() {} 12223 12224 func NewInsert_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_stmtContext { 12225 var p = new(Insert_stmtContext) 12226 12227 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 12228 12229 p.parser = parser 12230 p.RuleIndex = ParserRULE_insert_stmt 12231 12232 return p 12233 } 12234 12235 func (s *Insert_stmtContext) GetParser() antlr.Parser { return s.parser } 12236 12237 func (s *Insert_stmtContext) INTO_() antlr.TerminalNode { 12238 return s.GetToken(ParserINTO_, 0) 12239 } 12240 12241 func (s *Insert_stmtContext) Table_name() ITable_nameContext { 12242 var t antlr.RuleContext 12243 for _, ctx := range s.GetChildren() { 12244 if _, ok := ctx.(ITable_nameContext); ok { 12245 t = ctx.(antlr.RuleContext) 12246 break 12247 } 12248 } 12249 12250 if t == nil { 12251 return nil 12252 } 12253 12254 return t.(ITable_nameContext) 12255 } 12256 12257 func (s *Insert_stmtContext) INSERT_() antlr.TerminalNode { 12258 return s.GetToken(ParserINSERT_, 0) 12259 } 12260 12261 func (s *Insert_stmtContext) REPLACE_() antlr.TerminalNode { 12262 return s.GetToken(ParserREPLACE_, 0) 12263 } 12264 12265 func (s *Insert_stmtContext) OR_() antlr.TerminalNode { 12266 return s.GetToken(ParserOR_, 0) 12267 } 12268 12269 func (s *Insert_stmtContext) DEFAULT_() antlr.TerminalNode { 12270 return s.GetToken(ParserDEFAULT_, 0) 12271 } 12272 12273 func (s *Insert_stmtContext) VALUES_() antlr.TerminalNode { 12274 return s.GetToken(ParserVALUES_, 0) 12275 } 12276 12277 func (s *Insert_stmtContext) With_clause() IWith_clauseContext { 12278 var t antlr.RuleContext 12279 for _, ctx := range s.GetChildren() { 12280 if _, ok := ctx.(IWith_clauseContext); ok { 12281 t = ctx.(antlr.RuleContext) 12282 break 12283 } 12284 } 12285 12286 if t == nil { 12287 return nil 12288 } 12289 12290 return t.(IWith_clauseContext) 12291 } 12292 12293 func (s *Insert_stmtContext) ROLLBACK_() antlr.TerminalNode { 12294 return s.GetToken(ParserROLLBACK_, 0) 12295 } 12296 12297 func (s *Insert_stmtContext) ABORT_() antlr.TerminalNode { 12298 return s.GetToken(ParserABORT_, 0) 12299 } 12300 12301 func (s *Insert_stmtContext) FAIL_() antlr.TerminalNode { 12302 return s.GetToken(ParserFAIL_, 0) 12303 } 12304 12305 func (s *Insert_stmtContext) IGNORE_() antlr.TerminalNode { 12306 return s.GetToken(ParserIGNORE_, 0) 12307 } 12308 12309 func (s *Insert_stmtContext) Schema_name() ISchema_nameContext { 12310 var t antlr.RuleContext 12311 for _, ctx := range s.GetChildren() { 12312 if _, ok := ctx.(ISchema_nameContext); ok { 12313 t = ctx.(antlr.RuleContext) 12314 break 12315 } 12316 } 12317 12318 if t == nil { 12319 return nil 12320 } 12321 12322 return t.(ISchema_nameContext) 12323 } 12324 12325 func (s *Insert_stmtContext) DOT() antlr.TerminalNode { 12326 return s.GetToken(ParserDOT, 0) 12327 } 12328 12329 func (s *Insert_stmtContext) AS_() antlr.TerminalNode { 12330 return s.GetToken(ParserAS_, 0) 12331 } 12332 12333 func (s *Insert_stmtContext) Table_alias() ITable_aliasContext { 12334 var t antlr.RuleContext 12335 for _, ctx := range s.GetChildren() { 12336 if _, ok := ctx.(ITable_aliasContext); ok { 12337 t = ctx.(antlr.RuleContext) 12338 break 12339 } 12340 } 12341 12342 if t == nil { 12343 return nil 12344 } 12345 12346 return t.(ITable_aliasContext) 12347 } 12348 12349 func (s *Insert_stmtContext) AllOPEN_PAR() []antlr.TerminalNode { 12350 return s.GetTokens(ParserOPEN_PAR) 12351 } 12352 12353 func (s *Insert_stmtContext) OPEN_PAR(i int) antlr.TerminalNode { 12354 return s.GetToken(ParserOPEN_PAR, i) 12355 } 12356 12357 func (s *Insert_stmtContext) AllColumn_name() []IColumn_nameContext { 12358 children := s.GetChildren() 12359 len := 0 12360 for _, ctx := range children { 12361 if _, ok := ctx.(IColumn_nameContext); ok { 12362 len++ 12363 } 12364 } 12365 12366 tst := make([]IColumn_nameContext, len) 12367 i := 0 12368 for _, ctx := range children { 12369 if t, ok := ctx.(IColumn_nameContext); ok { 12370 tst[i] = t.(IColumn_nameContext) 12371 i++ 12372 } 12373 } 12374 12375 return tst 12376 } 12377 12378 func (s *Insert_stmtContext) Column_name(i int) IColumn_nameContext { 12379 var t antlr.RuleContext 12380 j := 0 12381 for _, ctx := range s.GetChildren() { 12382 if _, ok := ctx.(IColumn_nameContext); ok { 12383 if j == i { 12384 t = ctx.(antlr.RuleContext) 12385 break 12386 } 12387 j++ 12388 } 12389 } 12390 12391 if t == nil { 12392 return nil 12393 } 12394 12395 return t.(IColumn_nameContext) 12396 } 12397 12398 func (s *Insert_stmtContext) AllCLOSE_PAR() []antlr.TerminalNode { 12399 return s.GetTokens(ParserCLOSE_PAR) 12400 } 12401 12402 func (s *Insert_stmtContext) CLOSE_PAR(i int) antlr.TerminalNode { 12403 return s.GetToken(ParserCLOSE_PAR, i) 12404 } 12405 12406 func (s *Insert_stmtContext) Returning_clause() IReturning_clauseContext { 12407 var t antlr.RuleContext 12408 for _, ctx := range s.GetChildren() { 12409 if _, ok := ctx.(IReturning_clauseContext); ok { 12410 t = ctx.(antlr.RuleContext) 12411 break 12412 } 12413 } 12414 12415 if t == nil { 12416 return nil 12417 } 12418 12419 return t.(IReturning_clauseContext) 12420 } 12421 12422 func (s *Insert_stmtContext) AllCOMMA() []antlr.TerminalNode { 12423 return s.GetTokens(ParserCOMMA) 12424 } 12425 12426 func (s *Insert_stmtContext) COMMA(i int) antlr.TerminalNode { 12427 return s.GetToken(ParserCOMMA, i) 12428 } 12429 12430 func (s *Insert_stmtContext) AllExpr() []IExprContext { 12431 children := s.GetChildren() 12432 len := 0 12433 for _, ctx := range children { 12434 if _, ok := ctx.(IExprContext); ok { 12435 len++ 12436 } 12437 } 12438 12439 tst := make([]IExprContext, len) 12440 i := 0 12441 for _, ctx := range children { 12442 if t, ok := ctx.(IExprContext); ok { 12443 tst[i] = t.(IExprContext) 12444 i++ 12445 } 12446 } 12447 12448 return tst 12449 } 12450 12451 func (s *Insert_stmtContext) Expr(i int) IExprContext { 12452 var t antlr.RuleContext 12453 j := 0 12454 for _, ctx := range s.GetChildren() { 12455 if _, ok := ctx.(IExprContext); ok { 12456 if j == i { 12457 t = ctx.(antlr.RuleContext) 12458 break 12459 } 12460 j++ 12461 } 12462 } 12463 12464 if t == nil { 12465 return nil 12466 } 12467 12468 return t.(IExprContext) 12469 } 12470 12471 func (s *Insert_stmtContext) Select_stmt() ISelect_stmtContext { 12472 var t antlr.RuleContext 12473 for _, ctx := range s.GetChildren() { 12474 if _, ok := ctx.(ISelect_stmtContext); ok { 12475 t = ctx.(antlr.RuleContext) 12476 break 12477 } 12478 } 12479 12480 if t == nil { 12481 return nil 12482 } 12483 12484 return t.(ISelect_stmtContext) 12485 } 12486 12487 func (s *Insert_stmtContext) Upsert_clause() IUpsert_clauseContext { 12488 var t antlr.RuleContext 12489 for _, ctx := range s.GetChildren() { 12490 if _, ok := ctx.(IUpsert_clauseContext); ok { 12491 t = ctx.(antlr.RuleContext) 12492 break 12493 } 12494 } 12495 12496 if t == nil { 12497 return nil 12498 } 12499 12500 return t.(IUpsert_clauseContext) 12501 } 12502 12503 func (s *Insert_stmtContext) GetRuleContext() antlr.RuleContext { 12504 return s 12505 } 12506 12507 func (s *Insert_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 12508 return antlr.TreesStringTree(s, ruleNames, recog) 12509 } 12510 12511 func (s *Insert_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 12512 if listenerT, ok := listener.(ParserListener); ok { 12513 listenerT.EnterInsert_stmt(s) 12514 } 12515 } 12516 12517 func (s *Insert_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 12518 if listenerT, ok := listener.(ParserListener); ok { 12519 listenerT.ExitInsert_stmt(s) 12520 } 12521 } 12522 12523 func (s *Insert_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 12524 switch t := visitor.(type) { 12525 case ParserVisitor: 12526 return t.VisitInsert_stmt(s) 12527 12528 default: 12529 return t.VisitChildren(s) 12530 } 12531 } 12532 12533 func (p *Parser) Insert_stmt() (localctx IInsert_stmtContext) { 12534 this := p 12535 _ = this 12536 12537 localctx = NewInsert_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 12538 p.EnterRule(localctx, 70, ParserRULE_insert_stmt) 12539 var _la int 12540 12541 defer func() { 12542 p.ExitRule() 12543 }() 12544 12545 defer func() { 12546 if err := recover(); err != nil { 12547 if v, ok := err.(antlr.RecognitionException); ok { 12548 localctx.SetException(v) 12549 p.GetErrorHandler().ReportError(p, v) 12550 p.GetErrorHandler().Recover(p, v) 12551 } else { 12552 panic(err) 12553 } 12554 } 12555 }() 12556 12557 p.EnterOuterAlt(localctx, 1) 12558 p.SetState(1099) 12559 p.GetErrorHandler().Sync(p) 12560 _la = p.GetTokenStream().LA(1) 12561 12562 if _la == ParserWITH_ { 12563 { 12564 p.SetState(1098) 12565 p.With_clause() 12566 } 12567 12568 } 12569 p.SetState(1106) 12570 p.GetErrorHandler().Sync(p) 12571 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 139, p.GetParserRuleContext()) { 12572 case 1: 12573 { 12574 p.SetState(1101) 12575 p.Match(ParserINSERT_) 12576 } 12577 12578 case 2: 12579 { 12580 p.SetState(1102) 12581 p.Match(ParserREPLACE_) 12582 } 12583 12584 case 3: 12585 { 12586 p.SetState(1103) 12587 p.Match(ParserINSERT_) 12588 } 12589 { 12590 p.SetState(1104) 12591 p.Match(ParserOR_) 12592 } 12593 { 12594 p.SetState(1105) 12595 _la = p.GetTokenStream().LA(1) 12596 12597 if !(_la == ParserABORT_ || _la == ParserFAIL_ || _la == ParserIGNORE_ || _la == ParserREPLACE_ || _la == ParserROLLBACK_) { 12598 p.GetErrorHandler().RecoverInline(p) 12599 } else { 12600 p.GetErrorHandler().ReportMatch(p) 12601 p.Consume() 12602 } 12603 } 12604 12605 } 12606 { 12607 p.SetState(1108) 12608 p.Match(ParserINTO_) 12609 } 12610 p.SetState(1112) 12611 p.GetErrorHandler().Sync(p) 12612 12613 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 140, p.GetParserRuleContext()) == 1 { 12614 { 12615 p.SetState(1109) 12616 p.Schema_name() 12617 } 12618 { 12619 p.SetState(1110) 12620 p.Match(ParserDOT) 12621 } 12622 12623 } 12624 { 12625 p.SetState(1114) 12626 p.Table_name() 12627 } 12628 p.SetState(1117) 12629 p.GetErrorHandler().Sync(p) 12630 _la = p.GetTokenStream().LA(1) 12631 12632 if _la == ParserAS_ { 12633 { 12634 p.SetState(1115) 12635 p.Match(ParserAS_) 12636 } 12637 { 12638 p.SetState(1116) 12639 p.Table_alias() 12640 } 12641 12642 } 12643 p.SetState(1130) 12644 p.GetErrorHandler().Sync(p) 12645 _la = p.GetTokenStream().LA(1) 12646 12647 if _la == ParserOPEN_PAR { 12648 { 12649 p.SetState(1119) 12650 p.Match(ParserOPEN_PAR) 12651 } 12652 { 12653 p.SetState(1120) 12654 p.Column_name() 12655 } 12656 p.SetState(1125) 12657 p.GetErrorHandler().Sync(p) 12658 _la = p.GetTokenStream().LA(1) 12659 12660 for _la == ParserCOMMA { 12661 { 12662 p.SetState(1121) 12663 p.Match(ParserCOMMA) 12664 } 12665 { 12666 p.SetState(1122) 12667 p.Column_name() 12668 } 12669 12670 p.SetState(1127) 12671 p.GetErrorHandler().Sync(p) 12672 _la = p.GetTokenStream().LA(1) 12673 } 12674 { 12675 p.SetState(1128) 12676 p.Match(ParserCLOSE_PAR) 12677 } 12678 12679 } 12680 p.SetState(1168) 12681 p.GetErrorHandler().Sync(p) 12682 12683 switch p.GetTokenStream().LA(1) { 12684 case ParserSELECT_, ParserVALUES_, ParserWITH_: 12685 p.SetState(1161) 12686 p.GetErrorHandler().Sync(p) 12687 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 147, p.GetParserRuleContext()) { 12688 case 1: 12689 { 12690 p.SetState(1132) 12691 p.Match(ParserVALUES_) 12692 } 12693 { 12694 p.SetState(1133) 12695 p.Match(ParserOPEN_PAR) 12696 } 12697 { 12698 p.SetState(1134) 12699 p.expr(0) 12700 } 12701 p.SetState(1139) 12702 p.GetErrorHandler().Sync(p) 12703 _la = p.GetTokenStream().LA(1) 12704 12705 for _la == ParserCOMMA { 12706 { 12707 p.SetState(1135) 12708 p.Match(ParserCOMMA) 12709 } 12710 { 12711 p.SetState(1136) 12712 p.expr(0) 12713 } 12714 12715 p.SetState(1141) 12716 p.GetErrorHandler().Sync(p) 12717 _la = p.GetTokenStream().LA(1) 12718 } 12719 { 12720 p.SetState(1142) 12721 p.Match(ParserCLOSE_PAR) 12722 } 12723 p.SetState(1157) 12724 p.GetErrorHandler().Sync(p) 12725 _la = p.GetTokenStream().LA(1) 12726 12727 for _la == ParserCOMMA { 12728 { 12729 p.SetState(1143) 12730 p.Match(ParserCOMMA) 12731 } 12732 { 12733 p.SetState(1144) 12734 p.Match(ParserOPEN_PAR) 12735 } 12736 { 12737 p.SetState(1145) 12738 p.expr(0) 12739 } 12740 p.SetState(1150) 12741 p.GetErrorHandler().Sync(p) 12742 _la = p.GetTokenStream().LA(1) 12743 12744 for _la == ParserCOMMA { 12745 { 12746 p.SetState(1146) 12747 p.Match(ParserCOMMA) 12748 } 12749 { 12750 p.SetState(1147) 12751 p.expr(0) 12752 } 12753 12754 p.SetState(1152) 12755 p.GetErrorHandler().Sync(p) 12756 _la = p.GetTokenStream().LA(1) 12757 } 12758 { 12759 p.SetState(1153) 12760 p.Match(ParserCLOSE_PAR) 12761 } 12762 12763 p.SetState(1159) 12764 p.GetErrorHandler().Sync(p) 12765 _la = p.GetTokenStream().LA(1) 12766 } 12767 12768 case 2: 12769 { 12770 p.SetState(1160) 12771 p.Select_stmt() 12772 } 12773 12774 } 12775 p.SetState(1164) 12776 p.GetErrorHandler().Sync(p) 12777 _la = p.GetTokenStream().LA(1) 12778 12779 if _la == ParserON_ { 12780 { 12781 p.SetState(1163) 12782 p.Upsert_clause() 12783 } 12784 12785 } 12786 12787 case ParserDEFAULT_: 12788 { 12789 p.SetState(1166) 12790 p.Match(ParserDEFAULT_) 12791 } 12792 { 12793 p.SetState(1167) 12794 p.Match(ParserVALUES_) 12795 } 12796 12797 default: 12798 panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) 12799 } 12800 p.SetState(1171) 12801 p.GetErrorHandler().Sync(p) 12802 _la = p.GetTokenStream().LA(1) 12803 12804 if _la == ParserRETURNING_ { 12805 { 12806 p.SetState(1170) 12807 p.Returning_clause() 12808 } 12809 12810 } 12811 12812 return localctx 12813 } 12814 12815 // IReturning_clauseContext is an interface to support dynamic dispatch. 12816 type IReturning_clauseContext interface { 12817 antlr.ParserRuleContext 12818 12819 // GetParser returns the parser. 12820 GetParser() antlr.Parser 12821 12822 // IsReturning_clauseContext differentiates from other interfaces. 12823 IsReturning_clauseContext() 12824 } 12825 12826 type Returning_clauseContext struct { 12827 *antlr.BaseParserRuleContext 12828 parser antlr.Parser 12829 } 12830 12831 func NewEmptyReturning_clauseContext() *Returning_clauseContext { 12832 var p = new(Returning_clauseContext) 12833 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 12834 p.RuleIndex = ParserRULE_returning_clause 12835 return p 12836 } 12837 12838 func (*Returning_clauseContext) IsReturning_clauseContext() {} 12839 12840 func NewReturning_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Returning_clauseContext { 12841 var p = new(Returning_clauseContext) 12842 12843 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 12844 12845 p.parser = parser 12846 p.RuleIndex = ParserRULE_returning_clause 12847 12848 return p 12849 } 12850 12851 func (s *Returning_clauseContext) GetParser() antlr.Parser { return s.parser } 12852 12853 func (s *Returning_clauseContext) RETURNING_() antlr.TerminalNode { 12854 return s.GetToken(ParserRETURNING_, 0) 12855 } 12856 12857 func (s *Returning_clauseContext) AllResult_column() []IResult_columnContext { 12858 children := s.GetChildren() 12859 len := 0 12860 for _, ctx := range children { 12861 if _, ok := ctx.(IResult_columnContext); ok { 12862 len++ 12863 } 12864 } 12865 12866 tst := make([]IResult_columnContext, len) 12867 i := 0 12868 for _, ctx := range children { 12869 if t, ok := ctx.(IResult_columnContext); ok { 12870 tst[i] = t.(IResult_columnContext) 12871 i++ 12872 } 12873 } 12874 12875 return tst 12876 } 12877 12878 func (s *Returning_clauseContext) Result_column(i int) IResult_columnContext { 12879 var t antlr.RuleContext 12880 j := 0 12881 for _, ctx := range s.GetChildren() { 12882 if _, ok := ctx.(IResult_columnContext); ok { 12883 if j == i { 12884 t = ctx.(antlr.RuleContext) 12885 break 12886 } 12887 j++ 12888 } 12889 } 12890 12891 if t == nil { 12892 return nil 12893 } 12894 12895 return t.(IResult_columnContext) 12896 } 12897 12898 func (s *Returning_clauseContext) AllCOMMA() []antlr.TerminalNode { 12899 return s.GetTokens(ParserCOMMA) 12900 } 12901 12902 func (s *Returning_clauseContext) COMMA(i int) antlr.TerminalNode { 12903 return s.GetToken(ParserCOMMA, i) 12904 } 12905 12906 func (s *Returning_clauseContext) GetRuleContext() antlr.RuleContext { 12907 return s 12908 } 12909 12910 func (s *Returning_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 12911 return antlr.TreesStringTree(s, ruleNames, recog) 12912 } 12913 12914 func (s *Returning_clauseContext) EnterRule(listener antlr.ParseTreeListener) { 12915 if listenerT, ok := listener.(ParserListener); ok { 12916 listenerT.EnterReturning_clause(s) 12917 } 12918 } 12919 12920 func (s *Returning_clauseContext) ExitRule(listener antlr.ParseTreeListener) { 12921 if listenerT, ok := listener.(ParserListener); ok { 12922 listenerT.ExitReturning_clause(s) 12923 } 12924 } 12925 12926 func (s *Returning_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 12927 switch t := visitor.(type) { 12928 case ParserVisitor: 12929 return t.VisitReturning_clause(s) 12930 12931 default: 12932 return t.VisitChildren(s) 12933 } 12934 } 12935 12936 func (p *Parser) Returning_clause() (localctx IReturning_clauseContext) { 12937 this := p 12938 _ = this 12939 12940 localctx = NewReturning_clauseContext(p, p.GetParserRuleContext(), p.GetState()) 12941 p.EnterRule(localctx, 72, ParserRULE_returning_clause) 12942 var _la int 12943 12944 defer func() { 12945 p.ExitRule() 12946 }() 12947 12948 defer func() { 12949 if err := recover(); err != nil { 12950 if v, ok := err.(antlr.RecognitionException); ok { 12951 localctx.SetException(v) 12952 p.GetErrorHandler().ReportError(p, v) 12953 p.GetErrorHandler().Recover(p, v) 12954 } else { 12955 panic(err) 12956 } 12957 } 12958 }() 12959 12960 p.EnterOuterAlt(localctx, 1) 12961 { 12962 p.SetState(1173) 12963 p.Match(ParserRETURNING_) 12964 } 12965 { 12966 p.SetState(1174) 12967 p.Result_column() 12968 } 12969 p.SetState(1179) 12970 p.GetErrorHandler().Sync(p) 12971 _la = p.GetTokenStream().LA(1) 12972 12973 for _la == ParserCOMMA { 12974 { 12975 p.SetState(1175) 12976 p.Match(ParserCOMMA) 12977 } 12978 { 12979 p.SetState(1176) 12980 p.Result_column() 12981 } 12982 12983 p.SetState(1181) 12984 p.GetErrorHandler().Sync(p) 12985 _la = p.GetTokenStream().LA(1) 12986 } 12987 12988 return localctx 12989 } 12990 12991 // IUpsert_clauseContext is an interface to support dynamic dispatch. 12992 type IUpsert_clauseContext interface { 12993 antlr.ParserRuleContext 12994 12995 // GetParser returns the parser. 12996 GetParser() antlr.Parser 12997 12998 // IsUpsert_clauseContext differentiates from other interfaces. 12999 IsUpsert_clauseContext() 13000 } 13001 13002 type Upsert_clauseContext struct { 13003 *antlr.BaseParserRuleContext 13004 parser antlr.Parser 13005 } 13006 13007 func NewEmptyUpsert_clauseContext() *Upsert_clauseContext { 13008 var p = new(Upsert_clauseContext) 13009 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 13010 p.RuleIndex = ParserRULE_upsert_clause 13011 return p 13012 } 13013 13014 func (*Upsert_clauseContext) IsUpsert_clauseContext() {} 13015 13016 func NewUpsert_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Upsert_clauseContext { 13017 var p = new(Upsert_clauseContext) 13018 13019 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 13020 13021 p.parser = parser 13022 p.RuleIndex = ParserRULE_upsert_clause 13023 13024 return p 13025 } 13026 13027 func (s *Upsert_clauseContext) GetParser() antlr.Parser { return s.parser } 13028 13029 func (s *Upsert_clauseContext) ON_() antlr.TerminalNode { 13030 return s.GetToken(ParserON_, 0) 13031 } 13032 13033 func (s *Upsert_clauseContext) CONFLICT_() antlr.TerminalNode { 13034 return s.GetToken(ParserCONFLICT_, 0) 13035 } 13036 13037 func (s *Upsert_clauseContext) DO_() antlr.TerminalNode { 13038 return s.GetToken(ParserDO_, 0) 13039 } 13040 13041 func (s *Upsert_clauseContext) NOTHING_() antlr.TerminalNode { 13042 return s.GetToken(ParserNOTHING_, 0) 13043 } 13044 13045 func (s *Upsert_clauseContext) UPDATE_() antlr.TerminalNode { 13046 return s.GetToken(ParserUPDATE_, 0) 13047 } 13048 13049 func (s *Upsert_clauseContext) SET_() antlr.TerminalNode { 13050 return s.GetToken(ParserSET_, 0) 13051 } 13052 13053 func (s *Upsert_clauseContext) OPEN_PAR() antlr.TerminalNode { 13054 return s.GetToken(ParserOPEN_PAR, 0) 13055 } 13056 13057 func (s *Upsert_clauseContext) AllIndexed_column() []IIndexed_columnContext { 13058 children := s.GetChildren() 13059 len := 0 13060 for _, ctx := range children { 13061 if _, ok := ctx.(IIndexed_columnContext); ok { 13062 len++ 13063 } 13064 } 13065 13066 tst := make([]IIndexed_columnContext, len) 13067 i := 0 13068 for _, ctx := range children { 13069 if t, ok := ctx.(IIndexed_columnContext); ok { 13070 tst[i] = t.(IIndexed_columnContext) 13071 i++ 13072 } 13073 } 13074 13075 return tst 13076 } 13077 13078 func (s *Upsert_clauseContext) Indexed_column(i int) IIndexed_columnContext { 13079 var t antlr.RuleContext 13080 j := 0 13081 for _, ctx := range s.GetChildren() { 13082 if _, ok := ctx.(IIndexed_columnContext); ok { 13083 if j == i { 13084 t = ctx.(antlr.RuleContext) 13085 break 13086 } 13087 j++ 13088 } 13089 } 13090 13091 if t == nil { 13092 return nil 13093 } 13094 13095 return t.(IIndexed_columnContext) 13096 } 13097 13098 func (s *Upsert_clauseContext) CLOSE_PAR() antlr.TerminalNode { 13099 return s.GetToken(ParserCLOSE_PAR, 0) 13100 } 13101 13102 func (s *Upsert_clauseContext) AllASSIGN() []antlr.TerminalNode { 13103 return s.GetTokens(ParserASSIGN) 13104 } 13105 13106 func (s *Upsert_clauseContext) ASSIGN(i int) antlr.TerminalNode { 13107 return s.GetToken(ParserASSIGN, i) 13108 } 13109 13110 func (s *Upsert_clauseContext) AllExpr() []IExprContext { 13111 children := s.GetChildren() 13112 len := 0 13113 for _, ctx := range children { 13114 if _, ok := ctx.(IExprContext); ok { 13115 len++ 13116 } 13117 } 13118 13119 tst := make([]IExprContext, len) 13120 i := 0 13121 for _, ctx := range children { 13122 if t, ok := ctx.(IExprContext); ok { 13123 tst[i] = t.(IExprContext) 13124 i++ 13125 } 13126 } 13127 13128 return tst 13129 } 13130 13131 func (s *Upsert_clauseContext) Expr(i int) IExprContext { 13132 var t antlr.RuleContext 13133 j := 0 13134 for _, ctx := range s.GetChildren() { 13135 if _, ok := ctx.(IExprContext); ok { 13136 if j == i { 13137 t = ctx.(antlr.RuleContext) 13138 break 13139 } 13140 j++ 13141 } 13142 } 13143 13144 if t == nil { 13145 return nil 13146 } 13147 13148 return t.(IExprContext) 13149 } 13150 13151 func (s *Upsert_clauseContext) AllCOMMA() []antlr.TerminalNode { 13152 return s.GetTokens(ParserCOMMA) 13153 } 13154 13155 func (s *Upsert_clauseContext) COMMA(i int) antlr.TerminalNode { 13156 return s.GetToken(ParserCOMMA, i) 13157 } 13158 13159 func (s *Upsert_clauseContext) AllWHERE_() []antlr.TerminalNode { 13160 return s.GetTokens(ParserWHERE_) 13161 } 13162 13163 func (s *Upsert_clauseContext) WHERE_(i int) antlr.TerminalNode { 13164 return s.GetToken(ParserWHERE_, i) 13165 } 13166 13167 func (s *Upsert_clauseContext) AllColumn_name() []IColumn_nameContext { 13168 children := s.GetChildren() 13169 len := 0 13170 for _, ctx := range children { 13171 if _, ok := ctx.(IColumn_nameContext); ok { 13172 len++ 13173 } 13174 } 13175 13176 tst := make([]IColumn_nameContext, len) 13177 i := 0 13178 for _, ctx := range children { 13179 if t, ok := ctx.(IColumn_nameContext); ok { 13180 tst[i] = t.(IColumn_nameContext) 13181 i++ 13182 } 13183 } 13184 13185 return tst 13186 } 13187 13188 func (s *Upsert_clauseContext) Column_name(i int) IColumn_nameContext { 13189 var t antlr.RuleContext 13190 j := 0 13191 for _, ctx := range s.GetChildren() { 13192 if _, ok := ctx.(IColumn_nameContext); ok { 13193 if j == i { 13194 t = ctx.(antlr.RuleContext) 13195 break 13196 } 13197 j++ 13198 } 13199 } 13200 13201 if t == nil { 13202 return nil 13203 } 13204 13205 return t.(IColumn_nameContext) 13206 } 13207 13208 func (s *Upsert_clauseContext) AllColumn_name_list() []IColumn_name_listContext { 13209 children := s.GetChildren() 13210 len := 0 13211 for _, ctx := range children { 13212 if _, ok := ctx.(IColumn_name_listContext); ok { 13213 len++ 13214 } 13215 } 13216 13217 tst := make([]IColumn_name_listContext, len) 13218 i := 0 13219 for _, ctx := range children { 13220 if t, ok := ctx.(IColumn_name_listContext); ok { 13221 tst[i] = t.(IColumn_name_listContext) 13222 i++ 13223 } 13224 } 13225 13226 return tst 13227 } 13228 13229 func (s *Upsert_clauseContext) Column_name_list(i int) IColumn_name_listContext { 13230 var t antlr.RuleContext 13231 j := 0 13232 for _, ctx := range s.GetChildren() { 13233 if _, ok := ctx.(IColumn_name_listContext); ok { 13234 if j == i { 13235 t = ctx.(antlr.RuleContext) 13236 break 13237 } 13238 j++ 13239 } 13240 } 13241 13242 if t == nil { 13243 return nil 13244 } 13245 13246 return t.(IColumn_name_listContext) 13247 } 13248 13249 func (s *Upsert_clauseContext) GetRuleContext() antlr.RuleContext { 13250 return s 13251 } 13252 13253 func (s *Upsert_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 13254 return antlr.TreesStringTree(s, ruleNames, recog) 13255 } 13256 13257 func (s *Upsert_clauseContext) EnterRule(listener antlr.ParseTreeListener) { 13258 if listenerT, ok := listener.(ParserListener); ok { 13259 listenerT.EnterUpsert_clause(s) 13260 } 13261 } 13262 13263 func (s *Upsert_clauseContext) ExitRule(listener antlr.ParseTreeListener) { 13264 if listenerT, ok := listener.(ParserListener); ok { 13265 listenerT.ExitUpsert_clause(s) 13266 } 13267 } 13268 13269 func (s *Upsert_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 13270 switch t := visitor.(type) { 13271 case ParserVisitor: 13272 return t.VisitUpsert_clause(s) 13273 13274 default: 13275 return t.VisitChildren(s) 13276 } 13277 } 13278 13279 func (p *Parser) Upsert_clause() (localctx IUpsert_clauseContext) { 13280 this := p 13281 _ = this 13282 13283 localctx = NewUpsert_clauseContext(p, p.GetParserRuleContext(), p.GetState()) 13284 p.EnterRule(localctx, 74, ParserRULE_upsert_clause) 13285 var _la int 13286 13287 defer func() { 13288 p.ExitRule() 13289 }() 13290 13291 defer func() { 13292 if err := recover(); err != nil { 13293 if v, ok := err.(antlr.RecognitionException); ok { 13294 localctx.SetException(v) 13295 p.GetErrorHandler().ReportError(p, v) 13296 p.GetErrorHandler().Recover(p, v) 13297 } else { 13298 panic(err) 13299 } 13300 } 13301 }() 13302 13303 p.EnterOuterAlt(localctx, 1) 13304 { 13305 p.SetState(1182) 13306 p.Match(ParserON_) 13307 } 13308 { 13309 p.SetState(1183) 13310 p.Match(ParserCONFLICT_) 13311 } 13312 p.SetState(1198) 13313 p.GetErrorHandler().Sync(p) 13314 _la = p.GetTokenStream().LA(1) 13315 13316 if _la == ParserOPEN_PAR { 13317 { 13318 p.SetState(1184) 13319 p.Match(ParserOPEN_PAR) 13320 } 13321 { 13322 p.SetState(1185) 13323 p.Indexed_column() 13324 } 13325 p.SetState(1190) 13326 p.GetErrorHandler().Sync(p) 13327 _la = p.GetTokenStream().LA(1) 13328 13329 for _la == ParserCOMMA { 13330 { 13331 p.SetState(1186) 13332 p.Match(ParserCOMMA) 13333 } 13334 { 13335 p.SetState(1187) 13336 p.Indexed_column() 13337 } 13338 13339 p.SetState(1192) 13340 p.GetErrorHandler().Sync(p) 13341 _la = p.GetTokenStream().LA(1) 13342 } 13343 { 13344 p.SetState(1193) 13345 p.Match(ParserCLOSE_PAR) 13346 } 13347 p.SetState(1196) 13348 p.GetErrorHandler().Sync(p) 13349 _la = p.GetTokenStream().LA(1) 13350 13351 if _la == ParserWHERE_ { 13352 { 13353 p.SetState(1194) 13354 p.Match(ParserWHERE_) 13355 } 13356 { 13357 p.SetState(1195) 13358 p.expr(0) 13359 } 13360 13361 } 13362 13363 } 13364 { 13365 p.SetState(1200) 13366 p.Match(ParserDO_) 13367 } 13368 p.SetState(1227) 13369 p.GetErrorHandler().Sync(p) 13370 13371 switch p.GetTokenStream().LA(1) { 13372 case ParserNOTHING_: 13373 { 13374 p.SetState(1201) 13375 p.Match(ParserNOTHING_) 13376 } 13377 13378 case ParserUPDATE_: 13379 { 13380 p.SetState(1202) 13381 p.Match(ParserUPDATE_) 13382 } 13383 { 13384 p.SetState(1203) 13385 p.Match(ParserSET_) 13386 } 13387 13388 p.SetState(1206) 13389 p.GetErrorHandler().Sync(p) 13390 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 155, p.GetParserRuleContext()) { 13391 case 1: 13392 { 13393 p.SetState(1204) 13394 p.Column_name() 13395 } 13396 13397 case 2: 13398 { 13399 p.SetState(1205) 13400 p.Column_name_list() 13401 } 13402 13403 } 13404 { 13405 p.SetState(1208) 13406 p.Match(ParserASSIGN) 13407 } 13408 { 13409 p.SetState(1209) 13410 p.expr(0) 13411 } 13412 p.SetState(1220) 13413 p.GetErrorHandler().Sync(p) 13414 _la = p.GetTokenStream().LA(1) 13415 13416 for _la == ParserCOMMA { 13417 { 13418 p.SetState(1210) 13419 p.Match(ParserCOMMA) 13420 } 13421 p.SetState(1213) 13422 p.GetErrorHandler().Sync(p) 13423 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 156, p.GetParserRuleContext()) { 13424 case 1: 13425 { 13426 p.SetState(1211) 13427 p.Column_name() 13428 } 13429 13430 case 2: 13431 { 13432 p.SetState(1212) 13433 p.Column_name_list() 13434 } 13435 13436 } 13437 { 13438 p.SetState(1215) 13439 p.Match(ParserASSIGN) 13440 } 13441 { 13442 p.SetState(1216) 13443 p.expr(0) 13444 } 13445 13446 p.SetState(1222) 13447 p.GetErrorHandler().Sync(p) 13448 _la = p.GetTokenStream().LA(1) 13449 } 13450 p.SetState(1225) 13451 p.GetErrorHandler().Sync(p) 13452 _la = p.GetTokenStream().LA(1) 13453 13454 if _la == ParserWHERE_ { 13455 { 13456 p.SetState(1223) 13457 p.Match(ParserWHERE_) 13458 } 13459 { 13460 p.SetState(1224) 13461 p.expr(0) 13462 } 13463 13464 } 13465 13466 default: 13467 panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) 13468 } 13469 13470 return localctx 13471 } 13472 13473 // IPragma_stmtContext is an interface to support dynamic dispatch. 13474 type IPragma_stmtContext interface { 13475 antlr.ParserRuleContext 13476 13477 // GetParser returns the parser. 13478 GetParser() antlr.Parser 13479 13480 // IsPragma_stmtContext differentiates from other interfaces. 13481 IsPragma_stmtContext() 13482 } 13483 13484 type Pragma_stmtContext struct { 13485 *antlr.BaseParserRuleContext 13486 parser antlr.Parser 13487 } 13488 13489 func NewEmptyPragma_stmtContext() *Pragma_stmtContext { 13490 var p = new(Pragma_stmtContext) 13491 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 13492 p.RuleIndex = ParserRULE_pragma_stmt 13493 return p 13494 } 13495 13496 func (*Pragma_stmtContext) IsPragma_stmtContext() {} 13497 13498 func NewPragma_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pragma_stmtContext { 13499 var p = new(Pragma_stmtContext) 13500 13501 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 13502 13503 p.parser = parser 13504 p.RuleIndex = ParserRULE_pragma_stmt 13505 13506 return p 13507 } 13508 13509 func (s *Pragma_stmtContext) GetParser() antlr.Parser { return s.parser } 13510 13511 func (s *Pragma_stmtContext) PRAGMA_() antlr.TerminalNode { 13512 return s.GetToken(ParserPRAGMA_, 0) 13513 } 13514 13515 func (s *Pragma_stmtContext) Pragma_name() IPragma_nameContext { 13516 var t antlr.RuleContext 13517 for _, ctx := range s.GetChildren() { 13518 if _, ok := ctx.(IPragma_nameContext); ok { 13519 t = ctx.(antlr.RuleContext) 13520 break 13521 } 13522 } 13523 13524 if t == nil { 13525 return nil 13526 } 13527 13528 return t.(IPragma_nameContext) 13529 } 13530 13531 func (s *Pragma_stmtContext) Schema_name() ISchema_nameContext { 13532 var t antlr.RuleContext 13533 for _, ctx := range s.GetChildren() { 13534 if _, ok := ctx.(ISchema_nameContext); ok { 13535 t = ctx.(antlr.RuleContext) 13536 break 13537 } 13538 } 13539 13540 if t == nil { 13541 return nil 13542 } 13543 13544 return t.(ISchema_nameContext) 13545 } 13546 13547 func (s *Pragma_stmtContext) DOT() antlr.TerminalNode { 13548 return s.GetToken(ParserDOT, 0) 13549 } 13550 13551 func (s *Pragma_stmtContext) ASSIGN() antlr.TerminalNode { 13552 return s.GetToken(ParserASSIGN, 0) 13553 } 13554 13555 func (s *Pragma_stmtContext) Pragma_value() IPragma_valueContext { 13556 var t antlr.RuleContext 13557 for _, ctx := range s.GetChildren() { 13558 if _, ok := ctx.(IPragma_valueContext); ok { 13559 t = ctx.(antlr.RuleContext) 13560 break 13561 } 13562 } 13563 13564 if t == nil { 13565 return nil 13566 } 13567 13568 return t.(IPragma_valueContext) 13569 } 13570 13571 func (s *Pragma_stmtContext) OPEN_PAR() antlr.TerminalNode { 13572 return s.GetToken(ParserOPEN_PAR, 0) 13573 } 13574 13575 func (s *Pragma_stmtContext) CLOSE_PAR() antlr.TerminalNode { 13576 return s.GetToken(ParserCLOSE_PAR, 0) 13577 } 13578 13579 func (s *Pragma_stmtContext) GetRuleContext() antlr.RuleContext { 13580 return s 13581 } 13582 13583 func (s *Pragma_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 13584 return antlr.TreesStringTree(s, ruleNames, recog) 13585 } 13586 13587 func (s *Pragma_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 13588 if listenerT, ok := listener.(ParserListener); ok { 13589 listenerT.EnterPragma_stmt(s) 13590 } 13591 } 13592 13593 func (s *Pragma_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 13594 if listenerT, ok := listener.(ParserListener); ok { 13595 listenerT.ExitPragma_stmt(s) 13596 } 13597 } 13598 13599 func (s *Pragma_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 13600 switch t := visitor.(type) { 13601 case ParserVisitor: 13602 return t.VisitPragma_stmt(s) 13603 13604 default: 13605 return t.VisitChildren(s) 13606 } 13607 } 13608 13609 func (p *Parser) Pragma_stmt() (localctx IPragma_stmtContext) { 13610 this := p 13611 _ = this 13612 13613 localctx = NewPragma_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 13614 p.EnterRule(localctx, 76, ParserRULE_pragma_stmt) 13615 13616 defer func() { 13617 p.ExitRule() 13618 }() 13619 13620 defer func() { 13621 if err := recover(); err != nil { 13622 if v, ok := err.(antlr.RecognitionException); ok { 13623 localctx.SetException(v) 13624 p.GetErrorHandler().ReportError(p, v) 13625 p.GetErrorHandler().Recover(p, v) 13626 } else { 13627 panic(err) 13628 } 13629 } 13630 }() 13631 13632 p.EnterOuterAlt(localctx, 1) 13633 { 13634 p.SetState(1229) 13635 p.Match(ParserPRAGMA_) 13636 } 13637 p.SetState(1233) 13638 p.GetErrorHandler().Sync(p) 13639 13640 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 160, p.GetParserRuleContext()) == 1 { 13641 { 13642 p.SetState(1230) 13643 p.Schema_name() 13644 } 13645 { 13646 p.SetState(1231) 13647 p.Match(ParserDOT) 13648 } 13649 13650 } 13651 { 13652 p.SetState(1235) 13653 p.Pragma_name() 13654 } 13655 p.SetState(1242) 13656 p.GetErrorHandler().Sync(p) 13657 13658 switch p.GetTokenStream().LA(1) { 13659 case ParserASSIGN: 13660 { 13661 p.SetState(1236) 13662 p.Match(ParserASSIGN) 13663 } 13664 { 13665 p.SetState(1237) 13666 p.Pragma_value() 13667 } 13668 13669 case ParserOPEN_PAR: 13670 { 13671 p.SetState(1238) 13672 p.Match(ParserOPEN_PAR) 13673 } 13674 { 13675 p.SetState(1239) 13676 p.Pragma_value() 13677 } 13678 { 13679 p.SetState(1240) 13680 p.Match(ParserCLOSE_PAR) 13681 } 13682 13683 case ParserEOF, ParserSCOL, ParserALTER_, ParserANALYZE_, ParserATTACH_, ParserBEGIN_, ParserCOMMIT_, ParserCREATE_, ParserDELETE_, ParserDETACH_, ParserDROP_, ParserEND_, ParserEXPLAIN_, ParserINSERT_, ParserPRAGMA_, ParserREINDEX_, ParserRELEASE_, ParserREPLACE_, ParserROLLBACK_, ParserSAVEPOINT_, ParserSELECT_, ParserUPDATE_, ParserVACUUM_, ParserVALUES_, ParserWITH_: 13684 13685 default: 13686 } 13687 13688 return localctx 13689 } 13690 13691 // IPragma_valueContext is an interface to support dynamic dispatch. 13692 type IPragma_valueContext interface { 13693 antlr.ParserRuleContext 13694 13695 // GetParser returns the parser. 13696 GetParser() antlr.Parser 13697 13698 // IsPragma_valueContext differentiates from other interfaces. 13699 IsPragma_valueContext() 13700 } 13701 13702 type Pragma_valueContext struct { 13703 *antlr.BaseParserRuleContext 13704 parser antlr.Parser 13705 } 13706 13707 func NewEmptyPragma_valueContext() *Pragma_valueContext { 13708 var p = new(Pragma_valueContext) 13709 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 13710 p.RuleIndex = ParserRULE_pragma_value 13711 return p 13712 } 13713 13714 func (*Pragma_valueContext) IsPragma_valueContext() {} 13715 13716 func NewPragma_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pragma_valueContext { 13717 var p = new(Pragma_valueContext) 13718 13719 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 13720 13721 p.parser = parser 13722 p.RuleIndex = ParserRULE_pragma_value 13723 13724 return p 13725 } 13726 13727 func (s *Pragma_valueContext) GetParser() antlr.Parser { return s.parser } 13728 13729 func (s *Pragma_valueContext) Signed_number() ISigned_numberContext { 13730 var t antlr.RuleContext 13731 for _, ctx := range s.GetChildren() { 13732 if _, ok := ctx.(ISigned_numberContext); ok { 13733 t = ctx.(antlr.RuleContext) 13734 break 13735 } 13736 } 13737 13738 if t == nil { 13739 return nil 13740 } 13741 13742 return t.(ISigned_numberContext) 13743 } 13744 13745 func (s *Pragma_valueContext) Name() INameContext { 13746 var t antlr.RuleContext 13747 for _, ctx := range s.GetChildren() { 13748 if _, ok := ctx.(INameContext); ok { 13749 t = ctx.(antlr.RuleContext) 13750 break 13751 } 13752 } 13753 13754 if t == nil { 13755 return nil 13756 } 13757 13758 return t.(INameContext) 13759 } 13760 13761 func (s *Pragma_valueContext) STRING_LITERAL() antlr.TerminalNode { 13762 return s.GetToken(ParserSTRING_LITERAL, 0) 13763 } 13764 13765 func (s *Pragma_valueContext) GetRuleContext() antlr.RuleContext { 13766 return s 13767 } 13768 13769 func (s *Pragma_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 13770 return antlr.TreesStringTree(s, ruleNames, recog) 13771 } 13772 13773 func (s *Pragma_valueContext) EnterRule(listener antlr.ParseTreeListener) { 13774 if listenerT, ok := listener.(ParserListener); ok { 13775 listenerT.EnterPragma_value(s) 13776 } 13777 } 13778 13779 func (s *Pragma_valueContext) ExitRule(listener antlr.ParseTreeListener) { 13780 if listenerT, ok := listener.(ParserListener); ok { 13781 listenerT.ExitPragma_value(s) 13782 } 13783 } 13784 13785 func (s *Pragma_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 13786 switch t := visitor.(type) { 13787 case ParserVisitor: 13788 return t.VisitPragma_value(s) 13789 13790 default: 13791 return t.VisitChildren(s) 13792 } 13793 } 13794 13795 func (p *Parser) Pragma_value() (localctx IPragma_valueContext) { 13796 this := p 13797 _ = this 13798 13799 localctx = NewPragma_valueContext(p, p.GetParserRuleContext(), p.GetState()) 13800 p.EnterRule(localctx, 78, ParserRULE_pragma_value) 13801 13802 defer func() { 13803 p.ExitRule() 13804 }() 13805 13806 defer func() { 13807 if err := recover(); err != nil { 13808 if v, ok := err.(antlr.RecognitionException); ok { 13809 localctx.SetException(v) 13810 p.GetErrorHandler().ReportError(p, v) 13811 p.GetErrorHandler().Recover(p, v) 13812 } else { 13813 panic(err) 13814 } 13815 } 13816 }() 13817 13818 p.SetState(1247) 13819 p.GetErrorHandler().Sync(p) 13820 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 162, p.GetParserRuleContext()) { 13821 case 1: 13822 p.EnterOuterAlt(localctx, 1) 13823 { 13824 p.SetState(1244) 13825 p.Signed_number() 13826 } 13827 13828 case 2: 13829 p.EnterOuterAlt(localctx, 2) 13830 { 13831 p.SetState(1245) 13832 p.Name() 13833 } 13834 13835 case 3: 13836 p.EnterOuterAlt(localctx, 3) 13837 { 13838 p.SetState(1246) 13839 p.Match(ParserSTRING_LITERAL) 13840 } 13841 13842 } 13843 13844 return localctx 13845 } 13846 13847 // IReindex_stmtContext is an interface to support dynamic dispatch. 13848 type IReindex_stmtContext interface { 13849 antlr.ParserRuleContext 13850 13851 // GetParser returns the parser. 13852 GetParser() antlr.Parser 13853 13854 // IsReindex_stmtContext differentiates from other interfaces. 13855 IsReindex_stmtContext() 13856 } 13857 13858 type Reindex_stmtContext struct { 13859 *antlr.BaseParserRuleContext 13860 parser antlr.Parser 13861 } 13862 13863 func NewEmptyReindex_stmtContext() *Reindex_stmtContext { 13864 var p = new(Reindex_stmtContext) 13865 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 13866 p.RuleIndex = ParserRULE_reindex_stmt 13867 return p 13868 } 13869 13870 func (*Reindex_stmtContext) IsReindex_stmtContext() {} 13871 13872 func NewReindex_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reindex_stmtContext { 13873 var p = new(Reindex_stmtContext) 13874 13875 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 13876 13877 p.parser = parser 13878 p.RuleIndex = ParserRULE_reindex_stmt 13879 13880 return p 13881 } 13882 13883 func (s *Reindex_stmtContext) GetParser() antlr.Parser { return s.parser } 13884 13885 func (s *Reindex_stmtContext) REINDEX_() antlr.TerminalNode { 13886 return s.GetToken(ParserREINDEX_, 0) 13887 } 13888 13889 func (s *Reindex_stmtContext) Collation_name() ICollation_nameContext { 13890 var t antlr.RuleContext 13891 for _, ctx := range s.GetChildren() { 13892 if _, ok := ctx.(ICollation_nameContext); ok { 13893 t = ctx.(antlr.RuleContext) 13894 break 13895 } 13896 } 13897 13898 if t == nil { 13899 return nil 13900 } 13901 13902 return t.(ICollation_nameContext) 13903 } 13904 13905 func (s *Reindex_stmtContext) Table_name() ITable_nameContext { 13906 var t antlr.RuleContext 13907 for _, ctx := range s.GetChildren() { 13908 if _, ok := ctx.(ITable_nameContext); ok { 13909 t = ctx.(antlr.RuleContext) 13910 break 13911 } 13912 } 13913 13914 if t == nil { 13915 return nil 13916 } 13917 13918 return t.(ITable_nameContext) 13919 } 13920 13921 func (s *Reindex_stmtContext) Index_name() IIndex_nameContext { 13922 var t antlr.RuleContext 13923 for _, ctx := range s.GetChildren() { 13924 if _, ok := ctx.(IIndex_nameContext); ok { 13925 t = ctx.(antlr.RuleContext) 13926 break 13927 } 13928 } 13929 13930 if t == nil { 13931 return nil 13932 } 13933 13934 return t.(IIndex_nameContext) 13935 } 13936 13937 func (s *Reindex_stmtContext) Schema_name() ISchema_nameContext { 13938 var t antlr.RuleContext 13939 for _, ctx := range s.GetChildren() { 13940 if _, ok := ctx.(ISchema_nameContext); ok { 13941 t = ctx.(antlr.RuleContext) 13942 break 13943 } 13944 } 13945 13946 if t == nil { 13947 return nil 13948 } 13949 13950 return t.(ISchema_nameContext) 13951 } 13952 13953 func (s *Reindex_stmtContext) DOT() antlr.TerminalNode { 13954 return s.GetToken(ParserDOT, 0) 13955 } 13956 13957 func (s *Reindex_stmtContext) GetRuleContext() antlr.RuleContext { 13958 return s 13959 } 13960 13961 func (s *Reindex_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 13962 return antlr.TreesStringTree(s, ruleNames, recog) 13963 } 13964 13965 func (s *Reindex_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 13966 if listenerT, ok := listener.(ParserListener); ok { 13967 listenerT.EnterReindex_stmt(s) 13968 } 13969 } 13970 13971 func (s *Reindex_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 13972 if listenerT, ok := listener.(ParserListener); ok { 13973 listenerT.ExitReindex_stmt(s) 13974 } 13975 } 13976 13977 func (s *Reindex_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 13978 switch t := visitor.(type) { 13979 case ParserVisitor: 13980 return t.VisitReindex_stmt(s) 13981 13982 default: 13983 return t.VisitChildren(s) 13984 } 13985 } 13986 13987 func (p *Parser) Reindex_stmt() (localctx IReindex_stmtContext) { 13988 this := p 13989 _ = this 13990 13991 localctx = NewReindex_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 13992 p.EnterRule(localctx, 80, ParserRULE_reindex_stmt) 13993 13994 defer func() { 13995 p.ExitRule() 13996 }() 13997 13998 defer func() { 13999 if err := recover(); err != nil { 14000 if v, ok := err.(antlr.RecognitionException); ok { 14001 localctx.SetException(v) 14002 p.GetErrorHandler().ReportError(p, v) 14003 p.GetErrorHandler().Recover(p, v) 14004 } else { 14005 panic(err) 14006 } 14007 } 14008 }() 14009 14010 p.EnterOuterAlt(localctx, 1) 14011 { 14012 p.SetState(1249) 14013 p.Match(ParserREINDEX_) 14014 } 14015 p.SetState(1260) 14016 p.GetErrorHandler().Sync(p) 14017 14018 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 165, p.GetParserRuleContext()) == 1 { 14019 { 14020 p.SetState(1250) 14021 p.Collation_name() 14022 } 14023 14024 } else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 165, p.GetParserRuleContext()) == 2 { 14025 p.SetState(1254) 14026 p.GetErrorHandler().Sync(p) 14027 14028 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 163, p.GetParserRuleContext()) == 1 { 14029 { 14030 p.SetState(1251) 14031 p.Schema_name() 14032 } 14033 { 14034 p.SetState(1252) 14035 p.Match(ParserDOT) 14036 } 14037 14038 } 14039 p.SetState(1258) 14040 p.GetErrorHandler().Sync(p) 14041 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 164, p.GetParserRuleContext()) { 14042 case 1: 14043 { 14044 p.SetState(1256) 14045 p.Table_name() 14046 } 14047 14048 case 2: 14049 { 14050 p.SetState(1257) 14051 p.Index_name() 14052 } 14053 14054 } 14055 14056 } 14057 14058 return localctx 14059 } 14060 14061 // ISelect_stmtContext is an interface to support dynamic dispatch. 14062 type ISelect_stmtContext interface { 14063 antlr.ParserRuleContext 14064 14065 // GetParser returns the parser. 14066 GetParser() antlr.Parser 14067 14068 // IsSelect_stmtContext differentiates from other interfaces. 14069 IsSelect_stmtContext() 14070 } 14071 14072 type Select_stmtContext struct { 14073 *antlr.BaseParserRuleContext 14074 parser antlr.Parser 14075 } 14076 14077 func NewEmptySelect_stmtContext() *Select_stmtContext { 14078 var p = new(Select_stmtContext) 14079 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 14080 p.RuleIndex = ParserRULE_select_stmt 14081 return p 14082 } 14083 14084 func (*Select_stmtContext) IsSelect_stmtContext() {} 14085 14086 func NewSelect_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_stmtContext { 14087 var p = new(Select_stmtContext) 14088 14089 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 14090 14091 p.parser = parser 14092 p.RuleIndex = ParserRULE_select_stmt 14093 14094 return p 14095 } 14096 14097 func (s *Select_stmtContext) GetParser() antlr.Parser { return s.parser } 14098 14099 func (s *Select_stmtContext) AllSelect_core() []ISelect_coreContext { 14100 children := s.GetChildren() 14101 len := 0 14102 for _, ctx := range children { 14103 if _, ok := ctx.(ISelect_coreContext); ok { 14104 len++ 14105 } 14106 } 14107 14108 tst := make([]ISelect_coreContext, len) 14109 i := 0 14110 for _, ctx := range children { 14111 if t, ok := ctx.(ISelect_coreContext); ok { 14112 tst[i] = t.(ISelect_coreContext) 14113 i++ 14114 } 14115 } 14116 14117 return tst 14118 } 14119 14120 func (s *Select_stmtContext) Select_core(i int) ISelect_coreContext { 14121 var t antlr.RuleContext 14122 j := 0 14123 for _, ctx := range s.GetChildren() { 14124 if _, ok := ctx.(ISelect_coreContext); ok { 14125 if j == i { 14126 t = ctx.(antlr.RuleContext) 14127 break 14128 } 14129 j++ 14130 } 14131 } 14132 14133 if t == nil { 14134 return nil 14135 } 14136 14137 return t.(ISelect_coreContext) 14138 } 14139 14140 func (s *Select_stmtContext) Common_table_stmt() ICommon_table_stmtContext { 14141 var t antlr.RuleContext 14142 for _, ctx := range s.GetChildren() { 14143 if _, ok := ctx.(ICommon_table_stmtContext); ok { 14144 t = ctx.(antlr.RuleContext) 14145 break 14146 } 14147 } 14148 14149 if t == nil { 14150 return nil 14151 } 14152 14153 return t.(ICommon_table_stmtContext) 14154 } 14155 14156 func (s *Select_stmtContext) AllCompound_operator() []ICompound_operatorContext { 14157 children := s.GetChildren() 14158 len := 0 14159 for _, ctx := range children { 14160 if _, ok := ctx.(ICompound_operatorContext); ok { 14161 len++ 14162 } 14163 } 14164 14165 tst := make([]ICompound_operatorContext, len) 14166 i := 0 14167 for _, ctx := range children { 14168 if t, ok := ctx.(ICompound_operatorContext); ok { 14169 tst[i] = t.(ICompound_operatorContext) 14170 i++ 14171 } 14172 } 14173 14174 return tst 14175 } 14176 14177 func (s *Select_stmtContext) Compound_operator(i int) ICompound_operatorContext { 14178 var t antlr.RuleContext 14179 j := 0 14180 for _, ctx := range s.GetChildren() { 14181 if _, ok := ctx.(ICompound_operatorContext); ok { 14182 if j == i { 14183 t = ctx.(antlr.RuleContext) 14184 break 14185 } 14186 j++ 14187 } 14188 } 14189 14190 if t == nil { 14191 return nil 14192 } 14193 14194 return t.(ICompound_operatorContext) 14195 } 14196 14197 func (s *Select_stmtContext) Order_by_stmt() IOrder_by_stmtContext { 14198 var t antlr.RuleContext 14199 for _, ctx := range s.GetChildren() { 14200 if _, ok := ctx.(IOrder_by_stmtContext); ok { 14201 t = ctx.(antlr.RuleContext) 14202 break 14203 } 14204 } 14205 14206 if t == nil { 14207 return nil 14208 } 14209 14210 return t.(IOrder_by_stmtContext) 14211 } 14212 14213 func (s *Select_stmtContext) Limit_stmt() ILimit_stmtContext { 14214 var t antlr.RuleContext 14215 for _, ctx := range s.GetChildren() { 14216 if _, ok := ctx.(ILimit_stmtContext); ok { 14217 t = ctx.(antlr.RuleContext) 14218 break 14219 } 14220 } 14221 14222 if t == nil { 14223 return nil 14224 } 14225 14226 return t.(ILimit_stmtContext) 14227 } 14228 14229 func (s *Select_stmtContext) GetRuleContext() antlr.RuleContext { 14230 return s 14231 } 14232 14233 func (s *Select_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 14234 return antlr.TreesStringTree(s, ruleNames, recog) 14235 } 14236 14237 func (s *Select_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 14238 if listenerT, ok := listener.(ParserListener); ok { 14239 listenerT.EnterSelect_stmt(s) 14240 } 14241 } 14242 14243 func (s *Select_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 14244 if listenerT, ok := listener.(ParserListener); ok { 14245 listenerT.ExitSelect_stmt(s) 14246 } 14247 } 14248 14249 func (s *Select_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 14250 switch t := visitor.(type) { 14251 case ParserVisitor: 14252 return t.VisitSelect_stmt(s) 14253 14254 default: 14255 return t.VisitChildren(s) 14256 } 14257 } 14258 14259 func (p *Parser) Select_stmt() (localctx ISelect_stmtContext) { 14260 this := p 14261 _ = this 14262 14263 localctx = NewSelect_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 14264 p.EnterRule(localctx, 82, ParserRULE_select_stmt) 14265 var _la int 14266 14267 defer func() { 14268 p.ExitRule() 14269 }() 14270 14271 defer func() { 14272 if err := recover(); err != nil { 14273 if v, ok := err.(antlr.RecognitionException); ok { 14274 localctx.SetException(v) 14275 p.GetErrorHandler().ReportError(p, v) 14276 p.GetErrorHandler().Recover(p, v) 14277 } else { 14278 panic(err) 14279 } 14280 } 14281 }() 14282 14283 var _alt int 14284 14285 p.EnterOuterAlt(localctx, 1) 14286 p.SetState(1263) 14287 p.GetErrorHandler().Sync(p) 14288 _la = p.GetTokenStream().LA(1) 14289 14290 if _la == ParserWITH_ { 14291 { 14292 p.SetState(1262) 14293 p.Common_table_stmt() 14294 } 14295 14296 } 14297 { 14298 p.SetState(1265) 14299 p.Select_core() 14300 } 14301 p.SetState(1271) 14302 p.GetErrorHandler().Sync(p) 14303 _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 167, p.GetParserRuleContext()) 14304 14305 for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { 14306 if _alt == 1 { 14307 { 14308 p.SetState(1266) 14309 p.Compound_operator() 14310 } 14311 { 14312 p.SetState(1267) 14313 p.Select_core() 14314 } 14315 14316 } 14317 p.SetState(1273) 14318 p.GetErrorHandler().Sync(p) 14319 _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 167, p.GetParserRuleContext()) 14320 } 14321 p.SetState(1275) 14322 p.GetErrorHandler().Sync(p) 14323 _la = p.GetTokenStream().LA(1) 14324 14325 if _la == ParserORDER_ { 14326 { 14327 p.SetState(1274) 14328 p.Order_by_stmt() 14329 } 14330 14331 } 14332 p.SetState(1278) 14333 p.GetErrorHandler().Sync(p) 14334 _la = p.GetTokenStream().LA(1) 14335 14336 if _la == ParserLIMIT_ { 14337 { 14338 p.SetState(1277) 14339 p.Limit_stmt() 14340 } 14341 14342 } 14343 14344 return localctx 14345 } 14346 14347 // IJoin_clauseContext is an interface to support dynamic dispatch. 14348 type IJoin_clauseContext interface { 14349 antlr.ParserRuleContext 14350 14351 // GetParser returns the parser. 14352 GetParser() antlr.Parser 14353 14354 // IsJoin_clauseContext differentiates from other interfaces. 14355 IsJoin_clauseContext() 14356 } 14357 14358 type Join_clauseContext struct { 14359 *antlr.BaseParserRuleContext 14360 parser antlr.Parser 14361 } 14362 14363 func NewEmptyJoin_clauseContext() *Join_clauseContext { 14364 var p = new(Join_clauseContext) 14365 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 14366 p.RuleIndex = ParserRULE_join_clause 14367 return p 14368 } 14369 14370 func (*Join_clauseContext) IsJoin_clauseContext() {} 14371 14372 func NewJoin_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_clauseContext { 14373 var p = new(Join_clauseContext) 14374 14375 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 14376 14377 p.parser = parser 14378 p.RuleIndex = ParserRULE_join_clause 14379 14380 return p 14381 } 14382 14383 func (s *Join_clauseContext) GetParser() antlr.Parser { return s.parser } 14384 14385 func (s *Join_clauseContext) AllTable_or_subquery() []ITable_or_subqueryContext { 14386 children := s.GetChildren() 14387 len := 0 14388 for _, ctx := range children { 14389 if _, ok := ctx.(ITable_or_subqueryContext); ok { 14390 len++ 14391 } 14392 } 14393 14394 tst := make([]ITable_or_subqueryContext, len) 14395 i := 0 14396 for _, ctx := range children { 14397 if t, ok := ctx.(ITable_or_subqueryContext); ok { 14398 tst[i] = t.(ITable_or_subqueryContext) 14399 i++ 14400 } 14401 } 14402 14403 return tst 14404 } 14405 14406 func (s *Join_clauseContext) Table_or_subquery(i int) ITable_or_subqueryContext { 14407 var t antlr.RuleContext 14408 j := 0 14409 for _, ctx := range s.GetChildren() { 14410 if _, ok := ctx.(ITable_or_subqueryContext); ok { 14411 if j == i { 14412 t = ctx.(antlr.RuleContext) 14413 break 14414 } 14415 j++ 14416 } 14417 } 14418 14419 if t == nil { 14420 return nil 14421 } 14422 14423 return t.(ITable_or_subqueryContext) 14424 } 14425 14426 func (s *Join_clauseContext) AllJoin_operator() []IJoin_operatorContext { 14427 children := s.GetChildren() 14428 len := 0 14429 for _, ctx := range children { 14430 if _, ok := ctx.(IJoin_operatorContext); ok { 14431 len++ 14432 } 14433 } 14434 14435 tst := make([]IJoin_operatorContext, len) 14436 i := 0 14437 for _, ctx := range children { 14438 if t, ok := ctx.(IJoin_operatorContext); ok { 14439 tst[i] = t.(IJoin_operatorContext) 14440 i++ 14441 } 14442 } 14443 14444 return tst 14445 } 14446 14447 func (s *Join_clauseContext) Join_operator(i int) IJoin_operatorContext { 14448 var t antlr.RuleContext 14449 j := 0 14450 for _, ctx := range s.GetChildren() { 14451 if _, ok := ctx.(IJoin_operatorContext); ok { 14452 if j == i { 14453 t = ctx.(antlr.RuleContext) 14454 break 14455 } 14456 j++ 14457 } 14458 } 14459 14460 if t == nil { 14461 return nil 14462 } 14463 14464 return t.(IJoin_operatorContext) 14465 } 14466 14467 func (s *Join_clauseContext) AllJoin_constraint() []IJoin_constraintContext { 14468 children := s.GetChildren() 14469 len := 0 14470 for _, ctx := range children { 14471 if _, ok := ctx.(IJoin_constraintContext); ok { 14472 len++ 14473 } 14474 } 14475 14476 tst := make([]IJoin_constraintContext, len) 14477 i := 0 14478 for _, ctx := range children { 14479 if t, ok := ctx.(IJoin_constraintContext); ok { 14480 tst[i] = t.(IJoin_constraintContext) 14481 i++ 14482 } 14483 } 14484 14485 return tst 14486 } 14487 14488 func (s *Join_clauseContext) Join_constraint(i int) IJoin_constraintContext { 14489 var t antlr.RuleContext 14490 j := 0 14491 for _, ctx := range s.GetChildren() { 14492 if _, ok := ctx.(IJoin_constraintContext); ok { 14493 if j == i { 14494 t = ctx.(antlr.RuleContext) 14495 break 14496 } 14497 j++ 14498 } 14499 } 14500 14501 if t == nil { 14502 return nil 14503 } 14504 14505 return t.(IJoin_constraintContext) 14506 } 14507 14508 func (s *Join_clauseContext) GetRuleContext() antlr.RuleContext { 14509 return s 14510 } 14511 14512 func (s *Join_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 14513 return antlr.TreesStringTree(s, ruleNames, recog) 14514 } 14515 14516 func (s *Join_clauseContext) EnterRule(listener antlr.ParseTreeListener) { 14517 if listenerT, ok := listener.(ParserListener); ok { 14518 listenerT.EnterJoin_clause(s) 14519 } 14520 } 14521 14522 func (s *Join_clauseContext) ExitRule(listener antlr.ParseTreeListener) { 14523 if listenerT, ok := listener.(ParserListener); ok { 14524 listenerT.ExitJoin_clause(s) 14525 } 14526 } 14527 14528 func (s *Join_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 14529 switch t := visitor.(type) { 14530 case ParserVisitor: 14531 return t.VisitJoin_clause(s) 14532 14533 default: 14534 return t.VisitChildren(s) 14535 } 14536 } 14537 14538 func (p *Parser) Join_clause() (localctx IJoin_clauseContext) { 14539 this := p 14540 _ = this 14541 14542 localctx = NewJoin_clauseContext(p, p.GetParserRuleContext(), p.GetState()) 14543 p.EnterRule(localctx, 84, ParserRULE_join_clause) 14544 var _la int 14545 14546 defer func() { 14547 p.ExitRule() 14548 }() 14549 14550 defer func() { 14551 if err := recover(); err != nil { 14552 if v, ok := err.(antlr.RecognitionException); ok { 14553 localctx.SetException(v) 14554 p.GetErrorHandler().ReportError(p, v) 14555 p.GetErrorHandler().Recover(p, v) 14556 } else { 14557 panic(err) 14558 } 14559 } 14560 }() 14561 14562 p.EnterOuterAlt(localctx, 1) 14563 { 14564 p.SetState(1280) 14565 p.Table_or_subquery() 14566 } 14567 p.SetState(1288) 14568 p.GetErrorHandler().Sync(p) 14569 _la = p.GetTokenStream().LA(1) 14570 14571 for _la == ParserCOMMA || _la == ParserCROSS_ || (((_la-87)&-(0x1f+1)) == 0 && ((1<<uint((_la-87)))&((1<<(ParserINNER_-87))|(1<<(ParserJOIN_-87))|(1<<(ParserLEFT_-87))|(1<<(ParserNATURAL_-87)))) != 0) { 14572 { 14573 p.SetState(1281) 14574 p.Join_operator() 14575 } 14576 { 14577 p.SetState(1282) 14578 p.Table_or_subquery() 14579 } 14580 p.SetState(1284) 14581 p.GetErrorHandler().Sync(p) 14582 14583 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 170, p.GetParserRuleContext()) == 1 { 14584 { 14585 p.SetState(1283) 14586 p.Join_constraint() 14587 } 14588 14589 } 14590 14591 p.SetState(1290) 14592 p.GetErrorHandler().Sync(p) 14593 _la = p.GetTokenStream().LA(1) 14594 } 14595 14596 return localctx 14597 } 14598 14599 // ISelect_coreContext is an interface to support dynamic dispatch. 14600 type ISelect_coreContext interface { 14601 antlr.ParserRuleContext 14602 14603 // GetParser returns the parser. 14604 GetParser() antlr.Parser 14605 14606 // IsSelect_coreContext differentiates from other interfaces. 14607 IsSelect_coreContext() 14608 } 14609 14610 type Select_coreContext struct { 14611 *antlr.BaseParserRuleContext 14612 parser antlr.Parser 14613 } 14614 14615 func NewEmptySelect_coreContext() *Select_coreContext { 14616 var p = new(Select_coreContext) 14617 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 14618 p.RuleIndex = ParserRULE_select_core 14619 return p 14620 } 14621 14622 func (*Select_coreContext) IsSelect_coreContext() {} 14623 14624 func NewSelect_coreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_coreContext { 14625 var p = new(Select_coreContext) 14626 14627 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 14628 14629 p.parser = parser 14630 p.RuleIndex = ParserRULE_select_core 14631 14632 return p 14633 } 14634 14635 func (s *Select_coreContext) GetParser() antlr.Parser { return s.parser } 14636 14637 func (s *Select_coreContext) SELECT_() antlr.TerminalNode { 14638 return s.GetToken(ParserSELECT_, 0) 14639 } 14640 14641 func (s *Select_coreContext) AllResult_column() []IResult_columnContext { 14642 children := s.GetChildren() 14643 len := 0 14644 for _, ctx := range children { 14645 if _, ok := ctx.(IResult_columnContext); ok { 14646 len++ 14647 } 14648 } 14649 14650 tst := make([]IResult_columnContext, len) 14651 i := 0 14652 for _, ctx := range children { 14653 if t, ok := ctx.(IResult_columnContext); ok { 14654 tst[i] = t.(IResult_columnContext) 14655 i++ 14656 } 14657 } 14658 14659 return tst 14660 } 14661 14662 func (s *Select_coreContext) Result_column(i int) IResult_columnContext { 14663 var t antlr.RuleContext 14664 j := 0 14665 for _, ctx := range s.GetChildren() { 14666 if _, ok := ctx.(IResult_columnContext); ok { 14667 if j == i { 14668 t = ctx.(antlr.RuleContext) 14669 break 14670 } 14671 j++ 14672 } 14673 } 14674 14675 if t == nil { 14676 return nil 14677 } 14678 14679 return t.(IResult_columnContext) 14680 } 14681 14682 func (s *Select_coreContext) AllCOMMA() []antlr.TerminalNode { 14683 return s.GetTokens(ParserCOMMA) 14684 } 14685 14686 func (s *Select_coreContext) COMMA(i int) antlr.TerminalNode { 14687 return s.GetToken(ParserCOMMA, i) 14688 } 14689 14690 func (s *Select_coreContext) FROM_() antlr.TerminalNode { 14691 return s.GetToken(ParserFROM_, 0) 14692 } 14693 14694 func (s *Select_coreContext) WHERE_() antlr.TerminalNode { 14695 return s.GetToken(ParserWHERE_, 0) 14696 } 14697 14698 func (s *Select_coreContext) AllExpr() []IExprContext { 14699 children := s.GetChildren() 14700 len := 0 14701 for _, ctx := range children { 14702 if _, ok := ctx.(IExprContext); ok { 14703 len++ 14704 } 14705 } 14706 14707 tst := make([]IExprContext, len) 14708 i := 0 14709 for _, ctx := range children { 14710 if t, ok := ctx.(IExprContext); ok { 14711 tst[i] = t.(IExprContext) 14712 i++ 14713 } 14714 } 14715 14716 return tst 14717 } 14718 14719 func (s *Select_coreContext) Expr(i int) IExprContext { 14720 var t antlr.RuleContext 14721 j := 0 14722 for _, ctx := range s.GetChildren() { 14723 if _, ok := ctx.(IExprContext); ok { 14724 if j == i { 14725 t = ctx.(antlr.RuleContext) 14726 break 14727 } 14728 j++ 14729 } 14730 } 14731 14732 if t == nil { 14733 return nil 14734 } 14735 14736 return t.(IExprContext) 14737 } 14738 14739 func (s *Select_coreContext) GROUP_() antlr.TerminalNode { 14740 return s.GetToken(ParserGROUP_, 0) 14741 } 14742 14743 func (s *Select_coreContext) BY_() antlr.TerminalNode { 14744 return s.GetToken(ParserBY_, 0) 14745 } 14746 14747 func (s *Select_coreContext) WINDOW_() antlr.TerminalNode { 14748 return s.GetToken(ParserWINDOW_, 0) 14749 } 14750 14751 func (s *Select_coreContext) AllWindow_name() []IWindow_nameContext { 14752 children := s.GetChildren() 14753 len := 0 14754 for _, ctx := range children { 14755 if _, ok := ctx.(IWindow_nameContext); ok { 14756 len++ 14757 } 14758 } 14759 14760 tst := make([]IWindow_nameContext, len) 14761 i := 0 14762 for _, ctx := range children { 14763 if t, ok := ctx.(IWindow_nameContext); ok { 14764 tst[i] = t.(IWindow_nameContext) 14765 i++ 14766 } 14767 } 14768 14769 return tst 14770 } 14771 14772 func (s *Select_coreContext) Window_name(i int) IWindow_nameContext { 14773 var t antlr.RuleContext 14774 j := 0 14775 for _, ctx := range s.GetChildren() { 14776 if _, ok := ctx.(IWindow_nameContext); ok { 14777 if j == i { 14778 t = ctx.(antlr.RuleContext) 14779 break 14780 } 14781 j++ 14782 } 14783 } 14784 14785 if t == nil { 14786 return nil 14787 } 14788 14789 return t.(IWindow_nameContext) 14790 } 14791 14792 func (s *Select_coreContext) AllAS_() []antlr.TerminalNode { 14793 return s.GetTokens(ParserAS_) 14794 } 14795 14796 func (s *Select_coreContext) AS_(i int) antlr.TerminalNode { 14797 return s.GetToken(ParserAS_, i) 14798 } 14799 14800 func (s *Select_coreContext) AllWindow_defn() []IWindow_defnContext { 14801 children := s.GetChildren() 14802 len := 0 14803 for _, ctx := range children { 14804 if _, ok := ctx.(IWindow_defnContext); ok { 14805 len++ 14806 } 14807 } 14808 14809 tst := make([]IWindow_defnContext, len) 14810 i := 0 14811 for _, ctx := range children { 14812 if t, ok := ctx.(IWindow_defnContext); ok { 14813 tst[i] = t.(IWindow_defnContext) 14814 i++ 14815 } 14816 } 14817 14818 return tst 14819 } 14820 14821 func (s *Select_coreContext) Window_defn(i int) IWindow_defnContext { 14822 var t antlr.RuleContext 14823 j := 0 14824 for _, ctx := range s.GetChildren() { 14825 if _, ok := ctx.(IWindow_defnContext); ok { 14826 if j == i { 14827 t = ctx.(antlr.RuleContext) 14828 break 14829 } 14830 j++ 14831 } 14832 } 14833 14834 if t == nil { 14835 return nil 14836 } 14837 14838 return t.(IWindow_defnContext) 14839 } 14840 14841 func (s *Select_coreContext) DISTINCT_() antlr.TerminalNode { 14842 return s.GetToken(ParserDISTINCT_, 0) 14843 } 14844 14845 func (s *Select_coreContext) ALL_() antlr.TerminalNode { 14846 return s.GetToken(ParserALL_, 0) 14847 } 14848 14849 func (s *Select_coreContext) AllTable_or_subquery() []ITable_or_subqueryContext { 14850 children := s.GetChildren() 14851 len := 0 14852 for _, ctx := range children { 14853 if _, ok := ctx.(ITable_or_subqueryContext); ok { 14854 len++ 14855 } 14856 } 14857 14858 tst := make([]ITable_or_subqueryContext, len) 14859 i := 0 14860 for _, ctx := range children { 14861 if t, ok := ctx.(ITable_or_subqueryContext); ok { 14862 tst[i] = t.(ITable_or_subqueryContext) 14863 i++ 14864 } 14865 } 14866 14867 return tst 14868 } 14869 14870 func (s *Select_coreContext) Table_or_subquery(i int) ITable_or_subqueryContext { 14871 var t antlr.RuleContext 14872 j := 0 14873 for _, ctx := range s.GetChildren() { 14874 if _, ok := ctx.(ITable_or_subqueryContext); ok { 14875 if j == i { 14876 t = ctx.(antlr.RuleContext) 14877 break 14878 } 14879 j++ 14880 } 14881 } 14882 14883 if t == nil { 14884 return nil 14885 } 14886 14887 return t.(ITable_or_subqueryContext) 14888 } 14889 14890 func (s *Select_coreContext) Join_clause() IJoin_clauseContext { 14891 var t antlr.RuleContext 14892 for _, ctx := range s.GetChildren() { 14893 if _, ok := ctx.(IJoin_clauseContext); ok { 14894 t = ctx.(antlr.RuleContext) 14895 break 14896 } 14897 } 14898 14899 if t == nil { 14900 return nil 14901 } 14902 14903 return t.(IJoin_clauseContext) 14904 } 14905 14906 func (s *Select_coreContext) HAVING_() antlr.TerminalNode { 14907 return s.GetToken(ParserHAVING_, 0) 14908 } 14909 14910 func (s *Select_coreContext) VALUES_() antlr.TerminalNode { 14911 return s.GetToken(ParserVALUES_, 0) 14912 } 14913 14914 func (s *Select_coreContext) AllOPEN_PAR() []antlr.TerminalNode { 14915 return s.GetTokens(ParserOPEN_PAR) 14916 } 14917 14918 func (s *Select_coreContext) OPEN_PAR(i int) antlr.TerminalNode { 14919 return s.GetToken(ParserOPEN_PAR, i) 14920 } 14921 14922 func (s *Select_coreContext) AllCLOSE_PAR() []antlr.TerminalNode { 14923 return s.GetTokens(ParserCLOSE_PAR) 14924 } 14925 14926 func (s *Select_coreContext) CLOSE_PAR(i int) antlr.TerminalNode { 14927 return s.GetToken(ParserCLOSE_PAR, i) 14928 } 14929 14930 func (s *Select_coreContext) GetRuleContext() antlr.RuleContext { 14931 return s 14932 } 14933 14934 func (s *Select_coreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 14935 return antlr.TreesStringTree(s, ruleNames, recog) 14936 } 14937 14938 func (s *Select_coreContext) EnterRule(listener antlr.ParseTreeListener) { 14939 if listenerT, ok := listener.(ParserListener); ok { 14940 listenerT.EnterSelect_core(s) 14941 } 14942 } 14943 14944 func (s *Select_coreContext) ExitRule(listener antlr.ParseTreeListener) { 14945 if listenerT, ok := listener.(ParserListener); ok { 14946 listenerT.ExitSelect_core(s) 14947 } 14948 } 14949 14950 func (s *Select_coreContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 14951 switch t := visitor.(type) { 14952 case ParserVisitor: 14953 return t.VisitSelect_core(s) 14954 14955 default: 14956 return t.VisitChildren(s) 14957 } 14958 } 14959 14960 func (p *Parser) Select_core() (localctx ISelect_coreContext) { 14961 this := p 14962 _ = this 14963 14964 localctx = NewSelect_coreContext(p, p.GetParserRuleContext(), p.GetState()) 14965 p.EnterRule(localctx, 86, ParserRULE_select_core) 14966 var _la int 14967 14968 defer func() { 14969 p.ExitRule() 14970 }() 14971 14972 defer func() { 14973 if err := recover(); err != nil { 14974 if v, ok := err.(antlr.RecognitionException); ok { 14975 localctx.SetException(v) 14976 p.GetErrorHandler().ReportError(p, v) 14977 p.GetErrorHandler().Recover(p, v) 14978 } else { 14979 panic(err) 14980 } 14981 } 14982 }() 14983 14984 p.SetState(1381) 14985 p.GetErrorHandler().Sync(p) 14986 14987 switch p.GetTokenStream().LA(1) { 14988 case ParserSELECT_: 14989 p.EnterOuterAlt(localctx, 1) 14990 { 14991 p.SetState(1291) 14992 p.Match(ParserSELECT_) 14993 } 14994 p.SetState(1293) 14995 p.GetErrorHandler().Sync(p) 14996 14997 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 172, p.GetParserRuleContext()) == 1 { 14998 { 14999 p.SetState(1292) 15000 _la = p.GetTokenStream().LA(1) 15001 15002 if !(_la == ParserALL_ || _la == ParserDISTINCT_) { 15003 p.GetErrorHandler().RecoverInline(p) 15004 } else { 15005 p.GetErrorHandler().ReportMatch(p) 15006 p.Consume() 15007 } 15008 } 15009 15010 } 15011 { 15012 p.SetState(1295) 15013 p.Result_column() 15014 } 15015 p.SetState(1300) 15016 p.GetErrorHandler().Sync(p) 15017 _la = p.GetTokenStream().LA(1) 15018 15019 for _la == ParserCOMMA { 15020 { 15021 p.SetState(1296) 15022 p.Match(ParserCOMMA) 15023 } 15024 { 15025 p.SetState(1297) 15026 p.Result_column() 15027 } 15028 15029 p.SetState(1302) 15030 p.GetErrorHandler().Sync(p) 15031 _la = p.GetTokenStream().LA(1) 15032 } 15033 p.SetState(1315) 15034 p.GetErrorHandler().Sync(p) 15035 _la = p.GetTokenStream().LA(1) 15036 15037 if _la == ParserFROM_ { 15038 { 15039 p.SetState(1303) 15040 p.Match(ParserFROM_) 15041 } 15042 p.SetState(1313) 15043 p.GetErrorHandler().Sync(p) 15044 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 175, p.GetParserRuleContext()) { 15045 case 1: 15046 { 15047 p.SetState(1304) 15048 p.Table_or_subquery() 15049 } 15050 p.SetState(1309) 15051 p.GetErrorHandler().Sync(p) 15052 _la = p.GetTokenStream().LA(1) 15053 15054 for _la == ParserCOMMA { 15055 { 15056 p.SetState(1305) 15057 p.Match(ParserCOMMA) 15058 } 15059 { 15060 p.SetState(1306) 15061 p.Table_or_subquery() 15062 } 15063 15064 p.SetState(1311) 15065 p.GetErrorHandler().Sync(p) 15066 _la = p.GetTokenStream().LA(1) 15067 } 15068 15069 case 2: 15070 { 15071 p.SetState(1312) 15072 p.Join_clause() 15073 } 15074 15075 } 15076 15077 } 15078 p.SetState(1319) 15079 p.GetErrorHandler().Sync(p) 15080 _la = p.GetTokenStream().LA(1) 15081 15082 if _la == ParserWHERE_ { 15083 { 15084 p.SetState(1317) 15085 p.Match(ParserWHERE_) 15086 } 15087 { 15088 p.SetState(1318) 15089 p.expr(0) 15090 } 15091 15092 } 15093 p.SetState(1335) 15094 p.GetErrorHandler().Sync(p) 15095 _la = p.GetTokenStream().LA(1) 15096 15097 if _la == ParserGROUP_ { 15098 { 15099 p.SetState(1321) 15100 p.Match(ParserGROUP_) 15101 } 15102 { 15103 p.SetState(1322) 15104 p.Match(ParserBY_) 15105 } 15106 { 15107 p.SetState(1323) 15108 p.expr(0) 15109 } 15110 p.SetState(1328) 15111 p.GetErrorHandler().Sync(p) 15112 _la = p.GetTokenStream().LA(1) 15113 15114 for _la == ParserCOMMA { 15115 { 15116 p.SetState(1324) 15117 p.Match(ParserCOMMA) 15118 } 15119 { 15120 p.SetState(1325) 15121 p.expr(0) 15122 } 15123 15124 p.SetState(1330) 15125 p.GetErrorHandler().Sync(p) 15126 _la = p.GetTokenStream().LA(1) 15127 } 15128 p.SetState(1333) 15129 p.GetErrorHandler().Sync(p) 15130 _la = p.GetTokenStream().LA(1) 15131 15132 if _la == ParserHAVING_ { 15133 { 15134 p.SetState(1331) 15135 p.Match(ParserHAVING_) 15136 } 15137 { 15138 p.SetState(1332) 15139 p.expr(0) 15140 } 15141 15142 } 15143 15144 } 15145 p.SetState(1351) 15146 p.GetErrorHandler().Sync(p) 15147 _la = p.GetTokenStream().LA(1) 15148 15149 if _la == ParserWINDOW_ { 15150 { 15151 p.SetState(1337) 15152 p.Match(ParserWINDOW_) 15153 } 15154 { 15155 p.SetState(1338) 15156 p.Window_name() 15157 } 15158 { 15159 p.SetState(1339) 15160 p.Match(ParserAS_) 15161 } 15162 { 15163 p.SetState(1340) 15164 p.Window_defn() 15165 } 15166 p.SetState(1348) 15167 p.GetErrorHandler().Sync(p) 15168 _la = p.GetTokenStream().LA(1) 15169 15170 for _la == ParserCOMMA { 15171 { 15172 p.SetState(1341) 15173 p.Match(ParserCOMMA) 15174 } 15175 { 15176 p.SetState(1342) 15177 p.Window_name() 15178 } 15179 { 15180 p.SetState(1343) 15181 p.Match(ParserAS_) 15182 } 15183 { 15184 p.SetState(1344) 15185 p.Window_defn() 15186 } 15187 15188 p.SetState(1350) 15189 p.GetErrorHandler().Sync(p) 15190 _la = p.GetTokenStream().LA(1) 15191 } 15192 15193 } 15194 15195 case ParserVALUES_: 15196 p.EnterOuterAlt(localctx, 2) 15197 { 15198 p.SetState(1353) 15199 p.Match(ParserVALUES_) 15200 } 15201 { 15202 p.SetState(1354) 15203 p.Match(ParserOPEN_PAR) 15204 } 15205 { 15206 p.SetState(1355) 15207 p.expr(0) 15208 } 15209 p.SetState(1360) 15210 p.GetErrorHandler().Sync(p) 15211 _la = p.GetTokenStream().LA(1) 15212 15213 for _la == ParserCOMMA { 15214 { 15215 p.SetState(1356) 15216 p.Match(ParserCOMMA) 15217 } 15218 { 15219 p.SetState(1357) 15220 p.expr(0) 15221 } 15222 15223 p.SetState(1362) 15224 p.GetErrorHandler().Sync(p) 15225 _la = p.GetTokenStream().LA(1) 15226 } 15227 { 15228 p.SetState(1363) 15229 p.Match(ParserCLOSE_PAR) 15230 } 15231 p.SetState(1378) 15232 p.GetErrorHandler().Sync(p) 15233 _la = p.GetTokenStream().LA(1) 15234 15235 for _la == ParserCOMMA { 15236 { 15237 p.SetState(1364) 15238 p.Match(ParserCOMMA) 15239 } 15240 { 15241 p.SetState(1365) 15242 p.Match(ParserOPEN_PAR) 15243 } 15244 { 15245 p.SetState(1366) 15246 p.expr(0) 15247 } 15248 p.SetState(1371) 15249 p.GetErrorHandler().Sync(p) 15250 _la = p.GetTokenStream().LA(1) 15251 15252 for _la == ParserCOMMA { 15253 { 15254 p.SetState(1367) 15255 p.Match(ParserCOMMA) 15256 } 15257 { 15258 p.SetState(1368) 15259 p.expr(0) 15260 } 15261 15262 p.SetState(1373) 15263 p.GetErrorHandler().Sync(p) 15264 _la = p.GetTokenStream().LA(1) 15265 } 15266 { 15267 p.SetState(1374) 15268 p.Match(ParserCLOSE_PAR) 15269 } 15270 15271 p.SetState(1380) 15272 p.GetErrorHandler().Sync(p) 15273 _la = p.GetTokenStream().LA(1) 15274 } 15275 15276 default: 15277 panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) 15278 } 15279 15280 return localctx 15281 } 15282 15283 // IFactored_select_stmtContext is an interface to support dynamic dispatch. 15284 type IFactored_select_stmtContext interface { 15285 antlr.ParserRuleContext 15286 15287 // GetParser returns the parser. 15288 GetParser() antlr.Parser 15289 15290 // IsFactored_select_stmtContext differentiates from other interfaces. 15291 IsFactored_select_stmtContext() 15292 } 15293 15294 type Factored_select_stmtContext struct { 15295 *antlr.BaseParserRuleContext 15296 parser antlr.Parser 15297 } 15298 15299 func NewEmptyFactored_select_stmtContext() *Factored_select_stmtContext { 15300 var p = new(Factored_select_stmtContext) 15301 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 15302 p.RuleIndex = ParserRULE_factored_select_stmt 15303 return p 15304 } 15305 15306 func (*Factored_select_stmtContext) IsFactored_select_stmtContext() {} 15307 15308 func NewFactored_select_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Factored_select_stmtContext { 15309 var p = new(Factored_select_stmtContext) 15310 15311 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 15312 15313 p.parser = parser 15314 p.RuleIndex = ParserRULE_factored_select_stmt 15315 15316 return p 15317 } 15318 15319 func (s *Factored_select_stmtContext) GetParser() antlr.Parser { return s.parser } 15320 15321 func (s *Factored_select_stmtContext) Select_stmt() ISelect_stmtContext { 15322 var t antlr.RuleContext 15323 for _, ctx := range s.GetChildren() { 15324 if _, ok := ctx.(ISelect_stmtContext); ok { 15325 t = ctx.(antlr.RuleContext) 15326 break 15327 } 15328 } 15329 15330 if t == nil { 15331 return nil 15332 } 15333 15334 return t.(ISelect_stmtContext) 15335 } 15336 15337 func (s *Factored_select_stmtContext) GetRuleContext() antlr.RuleContext { 15338 return s 15339 } 15340 15341 func (s *Factored_select_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 15342 return antlr.TreesStringTree(s, ruleNames, recog) 15343 } 15344 15345 func (s *Factored_select_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 15346 if listenerT, ok := listener.(ParserListener); ok { 15347 listenerT.EnterFactored_select_stmt(s) 15348 } 15349 } 15350 15351 func (s *Factored_select_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 15352 if listenerT, ok := listener.(ParserListener); ok { 15353 listenerT.ExitFactored_select_stmt(s) 15354 } 15355 } 15356 15357 func (s *Factored_select_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 15358 switch t := visitor.(type) { 15359 case ParserVisitor: 15360 return t.VisitFactored_select_stmt(s) 15361 15362 default: 15363 return t.VisitChildren(s) 15364 } 15365 } 15366 15367 func (p *Parser) Factored_select_stmt() (localctx IFactored_select_stmtContext) { 15368 this := p 15369 _ = this 15370 15371 localctx = NewFactored_select_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 15372 p.EnterRule(localctx, 88, ParserRULE_factored_select_stmt) 15373 15374 defer func() { 15375 p.ExitRule() 15376 }() 15377 15378 defer func() { 15379 if err := recover(); err != nil { 15380 if v, ok := err.(antlr.RecognitionException); ok { 15381 localctx.SetException(v) 15382 p.GetErrorHandler().ReportError(p, v) 15383 p.GetErrorHandler().Recover(p, v) 15384 } else { 15385 panic(err) 15386 } 15387 } 15388 }() 15389 15390 p.EnterOuterAlt(localctx, 1) 15391 { 15392 p.SetState(1383) 15393 p.Select_stmt() 15394 } 15395 15396 return localctx 15397 } 15398 15399 // ISimple_select_stmtContext is an interface to support dynamic dispatch. 15400 type ISimple_select_stmtContext interface { 15401 antlr.ParserRuleContext 15402 15403 // GetParser returns the parser. 15404 GetParser() antlr.Parser 15405 15406 // IsSimple_select_stmtContext differentiates from other interfaces. 15407 IsSimple_select_stmtContext() 15408 } 15409 15410 type Simple_select_stmtContext struct { 15411 *antlr.BaseParserRuleContext 15412 parser antlr.Parser 15413 } 15414 15415 func NewEmptySimple_select_stmtContext() *Simple_select_stmtContext { 15416 var p = new(Simple_select_stmtContext) 15417 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 15418 p.RuleIndex = ParserRULE_simple_select_stmt 15419 return p 15420 } 15421 15422 func (*Simple_select_stmtContext) IsSimple_select_stmtContext() {} 15423 15424 func NewSimple_select_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_select_stmtContext { 15425 var p = new(Simple_select_stmtContext) 15426 15427 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 15428 15429 p.parser = parser 15430 p.RuleIndex = ParserRULE_simple_select_stmt 15431 15432 return p 15433 } 15434 15435 func (s *Simple_select_stmtContext) GetParser() antlr.Parser { return s.parser } 15436 15437 func (s *Simple_select_stmtContext) Select_core() ISelect_coreContext { 15438 var t antlr.RuleContext 15439 for _, ctx := range s.GetChildren() { 15440 if _, ok := ctx.(ISelect_coreContext); ok { 15441 t = ctx.(antlr.RuleContext) 15442 break 15443 } 15444 } 15445 15446 if t == nil { 15447 return nil 15448 } 15449 15450 return t.(ISelect_coreContext) 15451 } 15452 15453 func (s *Simple_select_stmtContext) Common_table_stmt() ICommon_table_stmtContext { 15454 var t antlr.RuleContext 15455 for _, ctx := range s.GetChildren() { 15456 if _, ok := ctx.(ICommon_table_stmtContext); ok { 15457 t = ctx.(antlr.RuleContext) 15458 break 15459 } 15460 } 15461 15462 if t == nil { 15463 return nil 15464 } 15465 15466 return t.(ICommon_table_stmtContext) 15467 } 15468 15469 func (s *Simple_select_stmtContext) Order_by_stmt() IOrder_by_stmtContext { 15470 var t antlr.RuleContext 15471 for _, ctx := range s.GetChildren() { 15472 if _, ok := ctx.(IOrder_by_stmtContext); ok { 15473 t = ctx.(antlr.RuleContext) 15474 break 15475 } 15476 } 15477 15478 if t == nil { 15479 return nil 15480 } 15481 15482 return t.(IOrder_by_stmtContext) 15483 } 15484 15485 func (s *Simple_select_stmtContext) Limit_stmt() ILimit_stmtContext { 15486 var t antlr.RuleContext 15487 for _, ctx := range s.GetChildren() { 15488 if _, ok := ctx.(ILimit_stmtContext); ok { 15489 t = ctx.(antlr.RuleContext) 15490 break 15491 } 15492 } 15493 15494 if t == nil { 15495 return nil 15496 } 15497 15498 return t.(ILimit_stmtContext) 15499 } 15500 15501 func (s *Simple_select_stmtContext) GetRuleContext() antlr.RuleContext { 15502 return s 15503 } 15504 15505 func (s *Simple_select_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 15506 return antlr.TreesStringTree(s, ruleNames, recog) 15507 } 15508 15509 func (s *Simple_select_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 15510 if listenerT, ok := listener.(ParserListener); ok { 15511 listenerT.EnterSimple_select_stmt(s) 15512 } 15513 } 15514 15515 func (s *Simple_select_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 15516 if listenerT, ok := listener.(ParserListener); ok { 15517 listenerT.ExitSimple_select_stmt(s) 15518 } 15519 } 15520 15521 func (s *Simple_select_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 15522 switch t := visitor.(type) { 15523 case ParserVisitor: 15524 return t.VisitSimple_select_stmt(s) 15525 15526 default: 15527 return t.VisitChildren(s) 15528 } 15529 } 15530 15531 func (p *Parser) Simple_select_stmt() (localctx ISimple_select_stmtContext) { 15532 this := p 15533 _ = this 15534 15535 localctx = NewSimple_select_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 15536 p.EnterRule(localctx, 90, ParserRULE_simple_select_stmt) 15537 var _la int 15538 15539 defer func() { 15540 p.ExitRule() 15541 }() 15542 15543 defer func() { 15544 if err := recover(); err != nil { 15545 if v, ok := err.(antlr.RecognitionException); ok { 15546 localctx.SetException(v) 15547 p.GetErrorHandler().ReportError(p, v) 15548 p.GetErrorHandler().Recover(p, v) 15549 } else { 15550 panic(err) 15551 } 15552 } 15553 }() 15554 15555 p.EnterOuterAlt(localctx, 1) 15556 p.SetState(1386) 15557 p.GetErrorHandler().Sync(p) 15558 _la = p.GetTokenStream().LA(1) 15559 15560 if _la == ParserWITH_ { 15561 { 15562 p.SetState(1385) 15563 p.Common_table_stmt() 15564 } 15565 15566 } 15567 { 15568 p.SetState(1388) 15569 p.Select_core() 15570 } 15571 p.SetState(1390) 15572 p.GetErrorHandler().Sync(p) 15573 _la = p.GetTokenStream().LA(1) 15574 15575 if _la == ParserORDER_ { 15576 { 15577 p.SetState(1389) 15578 p.Order_by_stmt() 15579 } 15580 15581 } 15582 p.SetState(1393) 15583 p.GetErrorHandler().Sync(p) 15584 _la = p.GetTokenStream().LA(1) 15585 15586 if _la == ParserLIMIT_ { 15587 { 15588 p.SetState(1392) 15589 p.Limit_stmt() 15590 } 15591 15592 } 15593 15594 return localctx 15595 } 15596 15597 // ICompound_select_stmtContext is an interface to support dynamic dispatch. 15598 type ICompound_select_stmtContext interface { 15599 antlr.ParserRuleContext 15600 15601 // GetParser returns the parser. 15602 GetParser() antlr.Parser 15603 15604 // IsCompound_select_stmtContext differentiates from other interfaces. 15605 IsCompound_select_stmtContext() 15606 } 15607 15608 type Compound_select_stmtContext struct { 15609 *antlr.BaseParserRuleContext 15610 parser antlr.Parser 15611 } 15612 15613 func NewEmptyCompound_select_stmtContext() *Compound_select_stmtContext { 15614 var p = new(Compound_select_stmtContext) 15615 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 15616 p.RuleIndex = ParserRULE_compound_select_stmt 15617 return p 15618 } 15619 15620 func (*Compound_select_stmtContext) IsCompound_select_stmtContext() {} 15621 15622 func NewCompound_select_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Compound_select_stmtContext { 15623 var p = new(Compound_select_stmtContext) 15624 15625 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 15626 15627 p.parser = parser 15628 p.RuleIndex = ParserRULE_compound_select_stmt 15629 15630 return p 15631 } 15632 15633 func (s *Compound_select_stmtContext) GetParser() antlr.Parser { return s.parser } 15634 15635 func (s *Compound_select_stmtContext) AllSelect_core() []ISelect_coreContext { 15636 children := s.GetChildren() 15637 len := 0 15638 for _, ctx := range children { 15639 if _, ok := ctx.(ISelect_coreContext); ok { 15640 len++ 15641 } 15642 } 15643 15644 tst := make([]ISelect_coreContext, len) 15645 i := 0 15646 for _, ctx := range children { 15647 if t, ok := ctx.(ISelect_coreContext); ok { 15648 tst[i] = t.(ISelect_coreContext) 15649 i++ 15650 } 15651 } 15652 15653 return tst 15654 } 15655 15656 func (s *Compound_select_stmtContext) Select_core(i int) ISelect_coreContext { 15657 var t antlr.RuleContext 15658 j := 0 15659 for _, ctx := range s.GetChildren() { 15660 if _, ok := ctx.(ISelect_coreContext); ok { 15661 if j == i { 15662 t = ctx.(antlr.RuleContext) 15663 break 15664 } 15665 j++ 15666 } 15667 } 15668 15669 if t == nil { 15670 return nil 15671 } 15672 15673 return t.(ISelect_coreContext) 15674 } 15675 15676 func (s *Compound_select_stmtContext) Common_table_stmt() ICommon_table_stmtContext { 15677 var t antlr.RuleContext 15678 for _, ctx := range s.GetChildren() { 15679 if _, ok := ctx.(ICommon_table_stmtContext); ok { 15680 t = ctx.(antlr.RuleContext) 15681 break 15682 } 15683 } 15684 15685 if t == nil { 15686 return nil 15687 } 15688 15689 return t.(ICommon_table_stmtContext) 15690 } 15691 15692 func (s *Compound_select_stmtContext) Order_by_stmt() IOrder_by_stmtContext { 15693 var t antlr.RuleContext 15694 for _, ctx := range s.GetChildren() { 15695 if _, ok := ctx.(IOrder_by_stmtContext); ok { 15696 t = ctx.(antlr.RuleContext) 15697 break 15698 } 15699 } 15700 15701 if t == nil { 15702 return nil 15703 } 15704 15705 return t.(IOrder_by_stmtContext) 15706 } 15707 15708 func (s *Compound_select_stmtContext) Limit_stmt() ILimit_stmtContext { 15709 var t antlr.RuleContext 15710 for _, ctx := range s.GetChildren() { 15711 if _, ok := ctx.(ILimit_stmtContext); ok { 15712 t = ctx.(antlr.RuleContext) 15713 break 15714 } 15715 } 15716 15717 if t == nil { 15718 return nil 15719 } 15720 15721 return t.(ILimit_stmtContext) 15722 } 15723 15724 func (s *Compound_select_stmtContext) AllUNION_() []antlr.TerminalNode { 15725 return s.GetTokens(ParserUNION_) 15726 } 15727 15728 func (s *Compound_select_stmtContext) UNION_(i int) antlr.TerminalNode { 15729 return s.GetToken(ParserUNION_, i) 15730 } 15731 15732 func (s *Compound_select_stmtContext) AllINTERSECT_() []antlr.TerminalNode { 15733 return s.GetTokens(ParserINTERSECT_) 15734 } 15735 15736 func (s *Compound_select_stmtContext) INTERSECT_(i int) antlr.TerminalNode { 15737 return s.GetToken(ParserINTERSECT_, i) 15738 } 15739 15740 func (s *Compound_select_stmtContext) AllEXCEPT_() []antlr.TerminalNode { 15741 return s.GetTokens(ParserEXCEPT_) 15742 } 15743 15744 func (s *Compound_select_stmtContext) EXCEPT_(i int) antlr.TerminalNode { 15745 return s.GetToken(ParserEXCEPT_, i) 15746 } 15747 15748 func (s *Compound_select_stmtContext) AllALL_() []antlr.TerminalNode { 15749 return s.GetTokens(ParserALL_) 15750 } 15751 15752 func (s *Compound_select_stmtContext) ALL_(i int) antlr.TerminalNode { 15753 return s.GetToken(ParserALL_, i) 15754 } 15755 15756 func (s *Compound_select_stmtContext) GetRuleContext() antlr.RuleContext { 15757 return s 15758 } 15759 15760 func (s *Compound_select_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 15761 return antlr.TreesStringTree(s, ruleNames, recog) 15762 } 15763 15764 func (s *Compound_select_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 15765 if listenerT, ok := listener.(ParserListener); ok { 15766 listenerT.EnterCompound_select_stmt(s) 15767 } 15768 } 15769 15770 func (s *Compound_select_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 15771 if listenerT, ok := listener.(ParserListener); ok { 15772 listenerT.ExitCompound_select_stmt(s) 15773 } 15774 } 15775 15776 func (s *Compound_select_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 15777 switch t := visitor.(type) { 15778 case ParserVisitor: 15779 return t.VisitCompound_select_stmt(s) 15780 15781 default: 15782 return t.VisitChildren(s) 15783 } 15784 } 15785 15786 func (p *Parser) Compound_select_stmt() (localctx ICompound_select_stmtContext) { 15787 this := p 15788 _ = this 15789 15790 localctx = NewCompound_select_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 15791 p.EnterRule(localctx, 92, ParserRULE_compound_select_stmt) 15792 var _la int 15793 15794 defer func() { 15795 p.ExitRule() 15796 }() 15797 15798 defer func() { 15799 if err := recover(); err != nil { 15800 if v, ok := err.(antlr.RecognitionException); ok { 15801 localctx.SetException(v) 15802 p.GetErrorHandler().ReportError(p, v) 15803 p.GetErrorHandler().Recover(p, v) 15804 } else { 15805 panic(err) 15806 } 15807 } 15808 }() 15809 15810 p.EnterOuterAlt(localctx, 1) 15811 p.SetState(1396) 15812 p.GetErrorHandler().Sync(p) 15813 _la = p.GetTokenStream().LA(1) 15814 15815 if _la == ParserWITH_ { 15816 { 15817 p.SetState(1395) 15818 p.Common_table_stmt() 15819 } 15820 15821 } 15822 { 15823 p.SetState(1398) 15824 p.Select_core() 15825 } 15826 p.SetState(1408) 15827 p.GetErrorHandler().Sync(p) 15828 _la = p.GetTokenStream().LA(1) 15829 15830 for ok := true; ok; ok = _la == ParserEXCEPT_ || _la == ParserINTERSECT_ || _la == ParserUNION_ { 15831 p.SetState(1405) 15832 p.GetErrorHandler().Sync(p) 15833 15834 switch p.GetTokenStream().LA(1) { 15835 case ParserUNION_: 15836 { 15837 p.SetState(1399) 15838 p.Match(ParserUNION_) 15839 } 15840 p.SetState(1401) 15841 p.GetErrorHandler().Sync(p) 15842 _la = p.GetTokenStream().LA(1) 15843 15844 if _la == ParserALL_ { 15845 { 15846 p.SetState(1400) 15847 p.Match(ParserALL_) 15848 } 15849 15850 } 15851 15852 case ParserINTERSECT_: 15853 { 15854 p.SetState(1403) 15855 p.Match(ParserINTERSECT_) 15856 } 15857 15858 case ParserEXCEPT_: 15859 { 15860 p.SetState(1404) 15861 p.Match(ParserEXCEPT_) 15862 } 15863 15864 default: 15865 panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) 15866 } 15867 { 15868 p.SetState(1407) 15869 p.Select_core() 15870 } 15871 15872 p.SetState(1410) 15873 p.GetErrorHandler().Sync(p) 15874 _la = p.GetTokenStream().LA(1) 15875 } 15876 p.SetState(1413) 15877 p.GetErrorHandler().Sync(p) 15878 _la = p.GetTokenStream().LA(1) 15879 15880 if _la == ParserORDER_ { 15881 { 15882 p.SetState(1412) 15883 p.Order_by_stmt() 15884 } 15885 15886 } 15887 p.SetState(1416) 15888 p.GetErrorHandler().Sync(p) 15889 _la = p.GetTokenStream().LA(1) 15890 15891 if _la == ParserLIMIT_ { 15892 { 15893 p.SetState(1415) 15894 p.Limit_stmt() 15895 } 15896 15897 } 15898 15899 return localctx 15900 } 15901 15902 // ITable_or_subqueryContext is an interface to support dynamic dispatch. 15903 type ITable_or_subqueryContext interface { 15904 antlr.ParserRuleContext 15905 15906 // GetParser returns the parser. 15907 GetParser() antlr.Parser 15908 15909 // IsTable_or_subqueryContext differentiates from other interfaces. 15910 IsTable_or_subqueryContext() 15911 } 15912 15913 type Table_or_subqueryContext struct { 15914 *antlr.BaseParserRuleContext 15915 parser antlr.Parser 15916 } 15917 15918 func NewEmptyTable_or_subqueryContext() *Table_or_subqueryContext { 15919 var p = new(Table_or_subqueryContext) 15920 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 15921 p.RuleIndex = ParserRULE_table_or_subquery 15922 return p 15923 } 15924 15925 func (*Table_or_subqueryContext) IsTable_or_subqueryContext() {} 15926 15927 func NewTable_or_subqueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_or_subqueryContext { 15928 var p = new(Table_or_subqueryContext) 15929 15930 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 15931 15932 p.parser = parser 15933 p.RuleIndex = ParserRULE_table_or_subquery 15934 15935 return p 15936 } 15937 15938 func (s *Table_or_subqueryContext) GetParser() antlr.Parser { return s.parser } 15939 15940 func (s *Table_or_subqueryContext) Table_name() ITable_nameContext { 15941 var t antlr.RuleContext 15942 for _, ctx := range s.GetChildren() { 15943 if _, ok := ctx.(ITable_nameContext); ok { 15944 t = ctx.(antlr.RuleContext) 15945 break 15946 } 15947 } 15948 15949 if t == nil { 15950 return nil 15951 } 15952 15953 return t.(ITable_nameContext) 15954 } 15955 15956 func (s *Table_or_subqueryContext) Schema_name() ISchema_nameContext { 15957 var t antlr.RuleContext 15958 for _, ctx := range s.GetChildren() { 15959 if _, ok := ctx.(ISchema_nameContext); ok { 15960 t = ctx.(antlr.RuleContext) 15961 break 15962 } 15963 } 15964 15965 if t == nil { 15966 return nil 15967 } 15968 15969 return t.(ISchema_nameContext) 15970 } 15971 15972 func (s *Table_or_subqueryContext) DOT() antlr.TerminalNode { 15973 return s.GetToken(ParserDOT, 0) 15974 } 15975 15976 func (s *Table_or_subqueryContext) Table_alias() ITable_aliasContext { 15977 var t antlr.RuleContext 15978 for _, ctx := range s.GetChildren() { 15979 if _, ok := ctx.(ITable_aliasContext); ok { 15980 t = ctx.(antlr.RuleContext) 15981 break 15982 } 15983 } 15984 15985 if t == nil { 15986 return nil 15987 } 15988 15989 return t.(ITable_aliasContext) 15990 } 15991 15992 func (s *Table_or_subqueryContext) INDEXED_() antlr.TerminalNode { 15993 return s.GetToken(ParserINDEXED_, 0) 15994 } 15995 15996 func (s *Table_or_subqueryContext) BY_() antlr.TerminalNode { 15997 return s.GetToken(ParserBY_, 0) 15998 } 15999 16000 func (s *Table_or_subqueryContext) Index_name() IIndex_nameContext { 16001 var t antlr.RuleContext 16002 for _, ctx := range s.GetChildren() { 16003 if _, ok := ctx.(IIndex_nameContext); ok { 16004 t = ctx.(antlr.RuleContext) 16005 break 16006 } 16007 } 16008 16009 if t == nil { 16010 return nil 16011 } 16012 16013 return t.(IIndex_nameContext) 16014 } 16015 16016 func (s *Table_or_subqueryContext) NOT_() antlr.TerminalNode { 16017 return s.GetToken(ParserNOT_, 0) 16018 } 16019 16020 func (s *Table_or_subqueryContext) AS_() antlr.TerminalNode { 16021 return s.GetToken(ParserAS_, 0) 16022 } 16023 16024 func (s *Table_or_subqueryContext) Table_function_name() ITable_function_nameContext { 16025 var t antlr.RuleContext 16026 for _, ctx := range s.GetChildren() { 16027 if _, ok := ctx.(ITable_function_nameContext); ok { 16028 t = ctx.(antlr.RuleContext) 16029 break 16030 } 16031 } 16032 16033 if t == nil { 16034 return nil 16035 } 16036 16037 return t.(ITable_function_nameContext) 16038 } 16039 16040 func (s *Table_or_subqueryContext) OPEN_PAR() antlr.TerminalNode { 16041 return s.GetToken(ParserOPEN_PAR, 0) 16042 } 16043 16044 func (s *Table_or_subqueryContext) AllExpr() []IExprContext { 16045 children := s.GetChildren() 16046 len := 0 16047 for _, ctx := range children { 16048 if _, ok := ctx.(IExprContext); ok { 16049 len++ 16050 } 16051 } 16052 16053 tst := make([]IExprContext, len) 16054 i := 0 16055 for _, ctx := range children { 16056 if t, ok := ctx.(IExprContext); ok { 16057 tst[i] = t.(IExprContext) 16058 i++ 16059 } 16060 } 16061 16062 return tst 16063 } 16064 16065 func (s *Table_or_subqueryContext) Expr(i int) IExprContext { 16066 var t antlr.RuleContext 16067 j := 0 16068 for _, ctx := range s.GetChildren() { 16069 if _, ok := ctx.(IExprContext); ok { 16070 if j == i { 16071 t = ctx.(antlr.RuleContext) 16072 break 16073 } 16074 j++ 16075 } 16076 } 16077 16078 if t == nil { 16079 return nil 16080 } 16081 16082 return t.(IExprContext) 16083 } 16084 16085 func (s *Table_or_subqueryContext) CLOSE_PAR() antlr.TerminalNode { 16086 return s.GetToken(ParserCLOSE_PAR, 0) 16087 } 16088 16089 func (s *Table_or_subqueryContext) AllCOMMA() []antlr.TerminalNode { 16090 return s.GetTokens(ParserCOMMA) 16091 } 16092 16093 func (s *Table_or_subqueryContext) COMMA(i int) antlr.TerminalNode { 16094 return s.GetToken(ParserCOMMA, i) 16095 } 16096 16097 func (s *Table_or_subqueryContext) AllTable_or_subquery() []ITable_or_subqueryContext { 16098 children := s.GetChildren() 16099 len := 0 16100 for _, ctx := range children { 16101 if _, ok := ctx.(ITable_or_subqueryContext); ok { 16102 len++ 16103 } 16104 } 16105 16106 tst := make([]ITable_or_subqueryContext, len) 16107 i := 0 16108 for _, ctx := range children { 16109 if t, ok := ctx.(ITable_or_subqueryContext); ok { 16110 tst[i] = t.(ITable_or_subqueryContext) 16111 i++ 16112 } 16113 } 16114 16115 return tst 16116 } 16117 16118 func (s *Table_or_subqueryContext) Table_or_subquery(i int) ITable_or_subqueryContext { 16119 var t antlr.RuleContext 16120 j := 0 16121 for _, ctx := range s.GetChildren() { 16122 if _, ok := ctx.(ITable_or_subqueryContext); ok { 16123 if j == i { 16124 t = ctx.(antlr.RuleContext) 16125 break 16126 } 16127 j++ 16128 } 16129 } 16130 16131 if t == nil { 16132 return nil 16133 } 16134 16135 return t.(ITable_or_subqueryContext) 16136 } 16137 16138 func (s *Table_or_subqueryContext) Join_clause() IJoin_clauseContext { 16139 var t antlr.RuleContext 16140 for _, ctx := range s.GetChildren() { 16141 if _, ok := ctx.(IJoin_clauseContext); ok { 16142 t = ctx.(antlr.RuleContext) 16143 break 16144 } 16145 } 16146 16147 if t == nil { 16148 return nil 16149 } 16150 16151 return t.(IJoin_clauseContext) 16152 } 16153 16154 func (s *Table_or_subqueryContext) Select_stmt() ISelect_stmtContext { 16155 var t antlr.RuleContext 16156 for _, ctx := range s.GetChildren() { 16157 if _, ok := ctx.(ISelect_stmtContext); ok { 16158 t = ctx.(antlr.RuleContext) 16159 break 16160 } 16161 } 16162 16163 if t == nil { 16164 return nil 16165 } 16166 16167 return t.(ISelect_stmtContext) 16168 } 16169 16170 func (s *Table_or_subqueryContext) GetRuleContext() antlr.RuleContext { 16171 return s 16172 } 16173 16174 func (s *Table_or_subqueryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 16175 return antlr.TreesStringTree(s, ruleNames, recog) 16176 } 16177 16178 func (s *Table_or_subqueryContext) EnterRule(listener antlr.ParseTreeListener) { 16179 if listenerT, ok := listener.(ParserListener); ok { 16180 listenerT.EnterTable_or_subquery(s) 16181 } 16182 } 16183 16184 func (s *Table_or_subqueryContext) ExitRule(listener antlr.ParseTreeListener) { 16185 if listenerT, ok := listener.(ParserListener); ok { 16186 listenerT.ExitTable_or_subquery(s) 16187 } 16188 } 16189 16190 func (s *Table_or_subqueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 16191 switch t := visitor.(type) { 16192 case ParserVisitor: 16193 return t.VisitTable_or_subquery(s) 16194 16195 default: 16196 return t.VisitChildren(s) 16197 } 16198 } 16199 16200 func (p *Parser) Table_or_subquery() (localctx ITable_or_subqueryContext) { 16201 this := p 16202 _ = this 16203 16204 localctx = NewTable_or_subqueryContext(p, p.GetParserRuleContext(), p.GetState()) 16205 p.EnterRule(localctx, 94, ParserRULE_table_or_subquery) 16206 var _la int 16207 16208 defer func() { 16209 p.ExitRule() 16210 }() 16211 16212 defer func() { 16213 if err := recover(); err != nil { 16214 if v, ok := err.(antlr.RecognitionException); ok { 16215 localctx.SetException(v) 16216 p.GetErrorHandler().ReportError(p, v) 16217 p.GetErrorHandler().Recover(p, v) 16218 } else { 16219 panic(err) 16220 } 16221 } 16222 }() 16223 16224 p.SetState(1482) 16225 p.GetErrorHandler().Sync(p) 16226 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 208, p.GetParserRuleContext()) { 16227 case 1: 16228 p.EnterOuterAlt(localctx, 1) 16229 p.SetState(1421) 16230 p.GetErrorHandler().Sync(p) 16231 16232 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 196, p.GetParserRuleContext()) == 1 { 16233 { 16234 p.SetState(1418) 16235 p.Schema_name() 16236 } 16237 { 16238 p.SetState(1419) 16239 p.Match(ParserDOT) 16240 } 16241 16242 } 16243 { 16244 p.SetState(1423) 16245 p.Table_name() 16246 } 16247 p.SetState(1428) 16248 p.GetErrorHandler().Sync(p) 16249 16250 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 198, p.GetParserRuleContext()) == 1 { 16251 p.SetState(1425) 16252 p.GetErrorHandler().Sync(p) 16253 16254 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 197, p.GetParserRuleContext()) == 1 { 16255 { 16256 p.SetState(1424) 16257 p.Match(ParserAS_) 16258 } 16259 16260 } 16261 { 16262 p.SetState(1427) 16263 p.Table_alias() 16264 } 16265 16266 } 16267 p.SetState(1435) 16268 p.GetErrorHandler().Sync(p) 16269 16270 switch p.GetTokenStream().LA(1) { 16271 case ParserINDEXED_: 16272 { 16273 p.SetState(1430) 16274 p.Match(ParserINDEXED_) 16275 } 16276 { 16277 p.SetState(1431) 16278 p.Match(ParserBY_) 16279 } 16280 { 16281 p.SetState(1432) 16282 p.Index_name() 16283 } 16284 16285 case ParserNOT_: 16286 { 16287 p.SetState(1433) 16288 p.Match(ParserNOT_) 16289 } 16290 { 16291 p.SetState(1434) 16292 p.Match(ParserINDEXED_) 16293 } 16294 16295 case ParserEOF, ParserSCOL, ParserCLOSE_PAR, ParserCOMMA, ParserALTER_, ParserANALYZE_, ParserATTACH_, ParserBEGIN_, ParserCOMMIT_, ParserCREATE_, ParserCROSS_, ParserDELETE_, ParserDETACH_, ParserDROP_, ParserEND_, ParserEXCEPT_, ParserEXPLAIN_, ParserGROUP_, ParserINNER_, ParserINSERT_, ParserINTERSECT_, ParserJOIN_, ParserLEFT_, ParserLIMIT_, ParserNATURAL_, ParserON_, ParserORDER_, ParserPRAGMA_, ParserREINDEX_, ParserRELEASE_, ParserREPLACE_, ParserRETURNING_, ParserROLLBACK_, ParserSAVEPOINT_, ParserSELECT_, ParserUNION_, ParserUPDATE_, ParserUSING_, ParserVACUUM_, ParserVALUES_, ParserWHERE_, ParserWITH_, ParserWINDOW_: 16296 16297 default: 16298 } 16299 16300 case 2: 16301 p.EnterOuterAlt(localctx, 2) 16302 p.SetState(1440) 16303 p.GetErrorHandler().Sync(p) 16304 16305 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 200, p.GetParserRuleContext()) == 1 { 16306 { 16307 p.SetState(1437) 16308 p.Schema_name() 16309 } 16310 { 16311 p.SetState(1438) 16312 p.Match(ParserDOT) 16313 } 16314 16315 } 16316 { 16317 p.SetState(1442) 16318 p.Table_function_name() 16319 } 16320 { 16321 p.SetState(1443) 16322 p.Match(ParserOPEN_PAR) 16323 } 16324 { 16325 p.SetState(1444) 16326 p.expr(0) 16327 } 16328 p.SetState(1449) 16329 p.GetErrorHandler().Sync(p) 16330 _la = p.GetTokenStream().LA(1) 16331 16332 for _la == ParserCOMMA { 16333 { 16334 p.SetState(1445) 16335 p.Match(ParserCOMMA) 16336 } 16337 { 16338 p.SetState(1446) 16339 p.expr(0) 16340 } 16341 16342 p.SetState(1451) 16343 p.GetErrorHandler().Sync(p) 16344 _la = p.GetTokenStream().LA(1) 16345 } 16346 { 16347 p.SetState(1452) 16348 p.Match(ParserCLOSE_PAR) 16349 } 16350 p.SetState(1457) 16351 p.GetErrorHandler().Sync(p) 16352 16353 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 203, p.GetParserRuleContext()) == 1 { 16354 p.SetState(1454) 16355 p.GetErrorHandler().Sync(p) 16356 16357 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 202, p.GetParserRuleContext()) == 1 { 16358 { 16359 p.SetState(1453) 16360 p.Match(ParserAS_) 16361 } 16362 16363 } 16364 { 16365 p.SetState(1456) 16366 p.Table_alias() 16367 } 16368 16369 } 16370 16371 case 3: 16372 p.EnterOuterAlt(localctx, 3) 16373 { 16374 p.SetState(1459) 16375 p.Match(ParserOPEN_PAR) 16376 } 16377 p.SetState(1469) 16378 p.GetErrorHandler().Sync(p) 16379 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 205, p.GetParserRuleContext()) { 16380 case 1: 16381 { 16382 p.SetState(1460) 16383 p.Table_or_subquery() 16384 } 16385 p.SetState(1465) 16386 p.GetErrorHandler().Sync(p) 16387 _la = p.GetTokenStream().LA(1) 16388 16389 for _la == ParserCOMMA { 16390 { 16391 p.SetState(1461) 16392 p.Match(ParserCOMMA) 16393 } 16394 { 16395 p.SetState(1462) 16396 p.Table_or_subquery() 16397 } 16398 16399 p.SetState(1467) 16400 p.GetErrorHandler().Sync(p) 16401 _la = p.GetTokenStream().LA(1) 16402 } 16403 16404 case 2: 16405 { 16406 p.SetState(1468) 16407 p.Join_clause() 16408 } 16409 16410 } 16411 { 16412 p.SetState(1471) 16413 p.Match(ParserCLOSE_PAR) 16414 } 16415 16416 case 4: 16417 p.EnterOuterAlt(localctx, 4) 16418 { 16419 p.SetState(1473) 16420 p.Match(ParserOPEN_PAR) 16421 } 16422 { 16423 p.SetState(1474) 16424 p.Select_stmt() 16425 } 16426 { 16427 p.SetState(1475) 16428 p.Match(ParserCLOSE_PAR) 16429 } 16430 p.SetState(1480) 16431 p.GetErrorHandler().Sync(p) 16432 16433 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 207, p.GetParserRuleContext()) == 1 { 16434 p.SetState(1477) 16435 p.GetErrorHandler().Sync(p) 16436 16437 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 206, p.GetParserRuleContext()) == 1 { 16438 { 16439 p.SetState(1476) 16440 p.Match(ParserAS_) 16441 } 16442 16443 } 16444 { 16445 p.SetState(1479) 16446 p.Table_alias() 16447 } 16448 16449 } 16450 16451 } 16452 16453 return localctx 16454 } 16455 16456 // IResult_columnContext is an interface to support dynamic dispatch. 16457 type IResult_columnContext interface { 16458 antlr.ParserRuleContext 16459 16460 // GetParser returns the parser. 16461 GetParser() antlr.Parser 16462 16463 // IsResult_columnContext differentiates from other interfaces. 16464 IsResult_columnContext() 16465 } 16466 16467 type Result_columnContext struct { 16468 *antlr.BaseParserRuleContext 16469 parser antlr.Parser 16470 } 16471 16472 func NewEmptyResult_columnContext() *Result_columnContext { 16473 var p = new(Result_columnContext) 16474 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 16475 p.RuleIndex = ParserRULE_result_column 16476 return p 16477 } 16478 16479 func (*Result_columnContext) IsResult_columnContext() {} 16480 16481 func NewResult_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Result_columnContext { 16482 var p = new(Result_columnContext) 16483 16484 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 16485 16486 p.parser = parser 16487 p.RuleIndex = ParserRULE_result_column 16488 16489 return p 16490 } 16491 16492 func (s *Result_columnContext) GetParser() antlr.Parser { return s.parser } 16493 16494 func (s *Result_columnContext) STAR() antlr.TerminalNode { 16495 return s.GetToken(ParserSTAR, 0) 16496 } 16497 16498 func (s *Result_columnContext) Table_name() ITable_nameContext { 16499 var t antlr.RuleContext 16500 for _, ctx := range s.GetChildren() { 16501 if _, ok := ctx.(ITable_nameContext); ok { 16502 t = ctx.(antlr.RuleContext) 16503 break 16504 } 16505 } 16506 16507 if t == nil { 16508 return nil 16509 } 16510 16511 return t.(ITable_nameContext) 16512 } 16513 16514 func (s *Result_columnContext) DOT() antlr.TerminalNode { 16515 return s.GetToken(ParserDOT, 0) 16516 } 16517 16518 func (s *Result_columnContext) Expr() IExprContext { 16519 var t antlr.RuleContext 16520 for _, ctx := range s.GetChildren() { 16521 if _, ok := ctx.(IExprContext); ok { 16522 t = ctx.(antlr.RuleContext) 16523 break 16524 } 16525 } 16526 16527 if t == nil { 16528 return nil 16529 } 16530 16531 return t.(IExprContext) 16532 } 16533 16534 func (s *Result_columnContext) Column_alias() IColumn_aliasContext { 16535 var t antlr.RuleContext 16536 for _, ctx := range s.GetChildren() { 16537 if _, ok := ctx.(IColumn_aliasContext); ok { 16538 t = ctx.(antlr.RuleContext) 16539 break 16540 } 16541 } 16542 16543 if t == nil { 16544 return nil 16545 } 16546 16547 return t.(IColumn_aliasContext) 16548 } 16549 16550 func (s *Result_columnContext) AS_() antlr.TerminalNode { 16551 return s.GetToken(ParserAS_, 0) 16552 } 16553 16554 func (s *Result_columnContext) GetRuleContext() antlr.RuleContext { 16555 return s 16556 } 16557 16558 func (s *Result_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 16559 return antlr.TreesStringTree(s, ruleNames, recog) 16560 } 16561 16562 func (s *Result_columnContext) EnterRule(listener antlr.ParseTreeListener) { 16563 if listenerT, ok := listener.(ParserListener); ok { 16564 listenerT.EnterResult_column(s) 16565 } 16566 } 16567 16568 func (s *Result_columnContext) ExitRule(listener antlr.ParseTreeListener) { 16569 if listenerT, ok := listener.(ParserListener); ok { 16570 listenerT.ExitResult_column(s) 16571 } 16572 } 16573 16574 func (s *Result_columnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 16575 switch t := visitor.(type) { 16576 case ParserVisitor: 16577 return t.VisitResult_column(s) 16578 16579 default: 16580 return t.VisitChildren(s) 16581 } 16582 } 16583 16584 func (p *Parser) Result_column() (localctx IResult_columnContext) { 16585 this := p 16586 _ = this 16587 16588 localctx = NewResult_columnContext(p, p.GetParserRuleContext(), p.GetState()) 16589 p.EnterRule(localctx, 96, ParserRULE_result_column) 16590 var _la int 16591 16592 defer func() { 16593 p.ExitRule() 16594 }() 16595 16596 defer func() { 16597 if err := recover(); err != nil { 16598 if v, ok := err.(antlr.RecognitionException); ok { 16599 localctx.SetException(v) 16600 p.GetErrorHandler().ReportError(p, v) 16601 p.GetErrorHandler().Recover(p, v) 16602 } else { 16603 panic(err) 16604 } 16605 } 16606 }() 16607 16608 p.SetState(1496) 16609 p.GetErrorHandler().Sync(p) 16610 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 211, p.GetParserRuleContext()) { 16611 case 1: 16612 p.EnterOuterAlt(localctx, 1) 16613 { 16614 p.SetState(1484) 16615 p.Match(ParserSTAR) 16616 } 16617 16618 case 2: 16619 p.EnterOuterAlt(localctx, 2) 16620 { 16621 p.SetState(1485) 16622 p.Table_name() 16623 } 16624 { 16625 p.SetState(1486) 16626 p.Match(ParserDOT) 16627 } 16628 { 16629 p.SetState(1487) 16630 p.Match(ParserSTAR) 16631 } 16632 16633 case 3: 16634 p.EnterOuterAlt(localctx, 3) 16635 { 16636 p.SetState(1489) 16637 p.expr(0) 16638 } 16639 p.SetState(1494) 16640 p.GetErrorHandler().Sync(p) 16641 _la = p.GetTokenStream().LA(1) 16642 16643 if _la == ParserAS_ || _la == ParserIDENTIFIER || _la == ParserSTRING_LITERAL { 16644 p.SetState(1491) 16645 p.GetErrorHandler().Sync(p) 16646 _la = p.GetTokenStream().LA(1) 16647 16648 if _la == ParserAS_ { 16649 { 16650 p.SetState(1490) 16651 p.Match(ParserAS_) 16652 } 16653 16654 } 16655 { 16656 p.SetState(1493) 16657 p.Column_alias() 16658 } 16659 16660 } 16661 16662 } 16663 16664 return localctx 16665 } 16666 16667 // IJoin_operatorContext is an interface to support dynamic dispatch. 16668 type IJoin_operatorContext interface { 16669 antlr.ParserRuleContext 16670 16671 // GetParser returns the parser. 16672 GetParser() antlr.Parser 16673 16674 // IsJoin_operatorContext differentiates from other interfaces. 16675 IsJoin_operatorContext() 16676 } 16677 16678 type Join_operatorContext struct { 16679 *antlr.BaseParserRuleContext 16680 parser antlr.Parser 16681 } 16682 16683 func NewEmptyJoin_operatorContext() *Join_operatorContext { 16684 var p = new(Join_operatorContext) 16685 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 16686 p.RuleIndex = ParserRULE_join_operator 16687 return p 16688 } 16689 16690 func (*Join_operatorContext) IsJoin_operatorContext() {} 16691 16692 func NewJoin_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_operatorContext { 16693 var p = new(Join_operatorContext) 16694 16695 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 16696 16697 p.parser = parser 16698 p.RuleIndex = ParserRULE_join_operator 16699 16700 return p 16701 } 16702 16703 func (s *Join_operatorContext) GetParser() antlr.Parser { return s.parser } 16704 16705 func (s *Join_operatorContext) COMMA() antlr.TerminalNode { 16706 return s.GetToken(ParserCOMMA, 0) 16707 } 16708 16709 func (s *Join_operatorContext) JOIN_() antlr.TerminalNode { 16710 return s.GetToken(ParserJOIN_, 0) 16711 } 16712 16713 func (s *Join_operatorContext) NATURAL_() antlr.TerminalNode { 16714 return s.GetToken(ParserNATURAL_, 0) 16715 } 16716 16717 func (s *Join_operatorContext) LEFT_() antlr.TerminalNode { 16718 return s.GetToken(ParserLEFT_, 0) 16719 } 16720 16721 func (s *Join_operatorContext) INNER_() antlr.TerminalNode { 16722 return s.GetToken(ParserINNER_, 0) 16723 } 16724 16725 func (s *Join_operatorContext) CROSS_() antlr.TerminalNode { 16726 return s.GetToken(ParserCROSS_, 0) 16727 } 16728 16729 func (s *Join_operatorContext) OUTER_() antlr.TerminalNode { 16730 return s.GetToken(ParserOUTER_, 0) 16731 } 16732 16733 func (s *Join_operatorContext) GetRuleContext() antlr.RuleContext { 16734 return s 16735 } 16736 16737 func (s *Join_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 16738 return antlr.TreesStringTree(s, ruleNames, recog) 16739 } 16740 16741 func (s *Join_operatorContext) EnterRule(listener antlr.ParseTreeListener) { 16742 if listenerT, ok := listener.(ParserListener); ok { 16743 listenerT.EnterJoin_operator(s) 16744 } 16745 } 16746 16747 func (s *Join_operatorContext) ExitRule(listener antlr.ParseTreeListener) { 16748 if listenerT, ok := listener.(ParserListener); ok { 16749 listenerT.ExitJoin_operator(s) 16750 } 16751 } 16752 16753 func (s *Join_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 16754 switch t := visitor.(type) { 16755 case ParserVisitor: 16756 return t.VisitJoin_operator(s) 16757 16758 default: 16759 return t.VisitChildren(s) 16760 } 16761 } 16762 16763 func (p *Parser) Join_operator() (localctx IJoin_operatorContext) { 16764 this := p 16765 _ = this 16766 16767 localctx = NewJoin_operatorContext(p, p.GetParserRuleContext(), p.GetState()) 16768 p.EnterRule(localctx, 98, ParserRULE_join_operator) 16769 var _la int 16770 16771 defer func() { 16772 p.ExitRule() 16773 }() 16774 16775 defer func() { 16776 if err := recover(); err != nil { 16777 if v, ok := err.(antlr.RecognitionException); ok { 16778 localctx.SetException(v) 16779 p.GetErrorHandler().ReportError(p, v) 16780 p.GetErrorHandler().Recover(p, v) 16781 } else { 16782 panic(err) 16783 } 16784 } 16785 }() 16786 16787 p.SetState(1511) 16788 p.GetErrorHandler().Sync(p) 16789 16790 switch p.GetTokenStream().LA(1) { 16791 case ParserCOMMA: 16792 p.EnterOuterAlt(localctx, 1) 16793 { 16794 p.SetState(1498) 16795 p.Match(ParserCOMMA) 16796 } 16797 16798 case ParserCROSS_, ParserINNER_, ParserJOIN_, ParserLEFT_, ParserNATURAL_: 16799 p.EnterOuterAlt(localctx, 2) 16800 p.SetState(1500) 16801 p.GetErrorHandler().Sync(p) 16802 _la = p.GetTokenStream().LA(1) 16803 16804 if _la == ParserNATURAL_ { 16805 { 16806 p.SetState(1499) 16807 p.Match(ParserNATURAL_) 16808 } 16809 16810 } 16811 p.SetState(1508) 16812 p.GetErrorHandler().Sync(p) 16813 16814 switch p.GetTokenStream().LA(1) { 16815 case ParserLEFT_: 16816 { 16817 p.SetState(1502) 16818 p.Match(ParserLEFT_) 16819 } 16820 p.SetState(1504) 16821 p.GetErrorHandler().Sync(p) 16822 _la = p.GetTokenStream().LA(1) 16823 16824 if _la == ParserOUTER_ { 16825 { 16826 p.SetState(1503) 16827 p.Match(ParserOUTER_) 16828 } 16829 16830 } 16831 16832 case ParserINNER_: 16833 { 16834 p.SetState(1506) 16835 p.Match(ParserINNER_) 16836 } 16837 16838 case ParserCROSS_: 16839 { 16840 p.SetState(1507) 16841 p.Match(ParserCROSS_) 16842 } 16843 16844 case ParserJOIN_: 16845 16846 default: 16847 } 16848 { 16849 p.SetState(1510) 16850 p.Match(ParserJOIN_) 16851 } 16852 16853 default: 16854 panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) 16855 } 16856 16857 return localctx 16858 } 16859 16860 // IJoin_constraintContext is an interface to support dynamic dispatch. 16861 type IJoin_constraintContext interface { 16862 antlr.ParserRuleContext 16863 16864 // GetParser returns the parser. 16865 GetParser() antlr.Parser 16866 16867 // IsJoin_constraintContext differentiates from other interfaces. 16868 IsJoin_constraintContext() 16869 } 16870 16871 type Join_constraintContext struct { 16872 *antlr.BaseParserRuleContext 16873 parser antlr.Parser 16874 } 16875 16876 func NewEmptyJoin_constraintContext() *Join_constraintContext { 16877 var p = new(Join_constraintContext) 16878 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 16879 p.RuleIndex = ParserRULE_join_constraint 16880 return p 16881 } 16882 16883 func (*Join_constraintContext) IsJoin_constraintContext() {} 16884 16885 func NewJoin_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_constraintContext { 16886 var p = new(Join_constraintContext) 16887 16888 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 16889 16890 p.parser = parser 16891 p.RuleIndex = ParserRULE_join_constraint 16892 16893 return p 16894 } 16895 16896 func (s *Join_constraintContext) GetParser() antlr.Parser { return s.parser } 16897 16898 func (s *Join_constraintContext) ON_() antlr.TerminalNode { 16899 return s.GetToken(ParserON_, 0) 16900 } 16901 16902 func (s *Join_constraintContext) Expr() IExprContext { 16903 var t antlr.RuleContext 16904 for _, ctx := range s.GetChildren() { 16905 if _, ok := ctx.(IExprContext); ok { 16906 t = ctx.(antlr.RuleContext) 16907 break 16908 } 16909 } 16910 16911 if t == nil { 16912 return nil 16913 } 16914 16915 return t.(IExprContext) 16916 } 16917 16918 func (s *Join_constraintContext) USING_() antlr.TerminalNode { 16919 return s.GetToken(ParserUSING_, 0) 16920 } 16921 16922 func (s *Join_constraintContext) OPEN_PAR() antlr.TerminalNode { 16923 return s.GetToken(ParserOPEN_PAR, 0) 16924 } 16925 16926 func (s *Join_constraintContext) AllColumn_name() []IColumn_nameContext { 16927 children := s.GetChildren() 16928 len := 0 16929 for _, ctx := range children { 16930 if _, ok := ctx.(IColumn_nameContext); ok { 16931 len++ 16932 } 16933 } 16934 16935 tst := make([]IColumn_nameContext, len) 16936 i := 0 16937 for _, ctx := range children { 16938 if t, ok := ctx.(IColumn_nameContext); ok { 16939 tst[i] = t.(IColumn_nameContext) 16940 i++ 16941 } 16942 } 16943 16944 return tst 16945 } 16946 16947 func (s *Join_constraintContext) Column_name(i int) IColumn_nameContext { 16948 var t antlr.RuleContext 16949 j := 0 16950 for _, ctx := range s.GetChildren() { 16951 if _, ok := ctx.(IColumn_nameContext); ok { 16952 if j == i { 16953 t = ctx.(antlr.RuleContext) 16954 break 16955 } 16956 j++ 16957 } 16958 } 16959 16960 if t == nil { 16961 return nil 16962 } 16963 16964 return t.(IColumn_nameContext) 16965 } 16966 16967 func (s *Join_constraintContext) CLOSE_PAR() antlr.TerminalNode { 16968 return s.GetToken(ParserCLOSE_PAR, 0) 16969 } 16970 16971 func (s *Join_constraintContext) AllCOMMA() []antlr.TerminalNode { 16972 return s.GetTokens(ParserCOMMA) 16973 } 16974 16975 func (s *Join_constraintContext) COMMA(i int) antlr.TerminalNode { 16976 return s.GetToken(ParserCOMMA, i) 16977 } 16978 16979 func (s *Join_constraintContext) GetRuleContext() antlr.RuleContext { 16980 return s 16981 } 16982 16983 func (s *Join_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 16984 return antlr.TreesStringTree(s, ruleNames, recog) 16985 } 16986 16987 func (s *Join_constraintContext) EnterRule(listener antlr.ParseTreeListener) { 16988 if listenerT, ok := listener.(ParserListener); ok { 16989 listenerT.EnterJoin_constraint(s) 16990 } 16991 } 16992 16993 func (s *Join_constraintContext) ExitRule(listener antlr.ParseTreeListener) { 16994 if listenerT, ok := listener.(ParserListener); ok { 16995 listenerT.ExitJoin_constraint(s) 16996 } 16997 } 16998 16999 func (s *Join_constraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 17000 switch t := visitor.(type) { 17001 case ParserVisitor: 17002 return t.VisitJoin_constraint(s) 17003 17004 default: 17005 return t.VisitChildren(s) 17006 } 17007 } 17008 17009 func (p *Parser) Join_constraint() (localctx IJoin_constraintContext) { 17010 this := p 17011 _ = this 17012 17013 localctx = NewJoin_constraintContext(p, p.GetParserRuleContext(), p.GetState()) 17014 p.EnterRule(localctx, 100, ParserRULE_join_constraint) 17015 var _la int 17016 17017 defer func() { 17018 p.ExitRule() 17019 }() 17020 17021 defer func() { 17022 if err := recover(); err != nil { 17023 if v, ok := err.(antlr.RecognitionException); ok { 17024 localctx.SetException(v) 17025 p.GetErrorHandler().ReportError(p, v) 17026 p.GetErrorHandler().Recover(p, v) 17027 } else { 17028 panic(err) 17029 } 17030 } 17031 }() 17032 17033 p.SetState(1527) 17034 p.GetErrorHandler().Sync(p) 17035 17036 switch p.GetTokenStream().LA(1) { 17037 case ParserON_: 17038 p.EnterOuterAlt(localctx, 1) 17039 { 17040 p.SetState(1513) 17041 p.Match(ParserON_) 17042 } 17043 { 17044 p.SetState(1514) 17045 p.expr(0) 17046 } 17047 17048 case ParserUSING_: 17049 p.EnterOuterAlt(localctx, 2) 17050 { 17051 p.SetState(1515) 17052 p.Match(ParserUSING_) 17053 } 17054 { 17055 p.SetState(1516) 17056 p.Match(ParserOPEN_PAR) 17057 } 17058 { 17059 p.SetState(1517) 17060 p.Column_name() 17061 } 17062 p.SetState(1522) 17063 p.GetErrorHandler().Sync(p) 17064 _la = p.GetTokenStream().LA(1) 17065 17066 for _la == ParserCOMMA { 17067 { 17068 p.SetState(1518) 17069 p.Match(ParserCOMMA) 17070 } 17071 { 17072 p.SetState(1519) 17073 p.Column_name() 17074 } 17075 17076 p.SetState(1524) 17077 p.GetErrorHandler().Sync(p) 17078 _la = p.GetTokenStream().LA(1) 17079 } 17080 { 17081 p.SetState(1525) 17082 p.Match(ParserCLOSE_PAR) 17083 } 17084 17085 default: 17086 panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) 17087 } 17088 17089 return localctx 17090 } 17091 17092 // ICompound_operatorContext is an interface to support dynamic dispatch. 17093 type ICompound_operatorContext interface { 17094 antlr.ParserRuleContext 17095 17096 // GetParser returns the parser. 17097 GetParser() antlr.Parser 17098 17099 // IsCompound_operatorContext differentiates from other interfaces. 17100 IsCompound_operatorContext() 17101 } 17102 17103 type Compound_operatorContext struct { 17104 *antlr.BaseParserRuleContext 17105 parser antlr.Parser 17106 } 17107 17108 func NewEmptyCompound_operatorContext() *Compound_operatorContext { 17109 var p = new(Compound_operatorContext) 17110 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 17111 p.RuleIndex = ParserRULE_compound_operator 17112 return p 17113 } 17114 17115 func (*Compound_operatorContext) IsCompound_operatorContext() {} 17116 17117 func NewCompound_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Compound_operatorContext { 17118 var p = new(Compound_operatorContext) 17119 17120 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 17121 17122 p.parser = parser 17123 p.RuleIndex = ParserRULE_compound_operator 17124 17125 return p 17126 } 17127 17128 func (s *Compound_operatorContext) GetParser() antlr.Parser { return s.parser } 17129 17130 func (s *Compound_operatorContext) UNION_() antlr.TerminalNode { 17131 return s.GetToken(ParserUNION_, 0) 17132 } 17133 17134 func (s *Compound_operatorContext) ALL_() antlr.TerminalNode { 17135 return s.GetToken(ParserALL_, 0) 17136 } 17137 17138 func (s *Compound_operatorContext) INTERSECT_() antlr.TerminalNode { 17139 return s.GetToken(ParserINTERSECT_, 0) 17140 } 17141 17142 func (s *Compound_operatorContext) EXCEPT_() antlr.TerminalNode { 17143 return s.GetToken(ParserEXCEPT_, 0) 17144 } 17145 17146 func (s *Compound_operatorContext) GetRuleContext() antlr.RuleContext { 17147 return s 17148 } 17149 17150 func (s *Compound_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 17151 return antlr.TreesStringTree(s, ruleNames, recog) 17152 } 17153 17154 func (s *Compound_operatorContext) EnterRule(listener antlr.ParseTreeListener) { 17155 if listenerT, ok := listener.(ParserListener); ok { 17156 listenerT.EnterCompound_operator(s) 17157 } 17158 } 17159 17160 func (s *Compound_operatorContext) ExitRule(listener antlr.ParseTreeListener) { 17161 if listenerT, ok := listener.(ParserListener); ok { 17162 listenerT.ExitCompound_operator(s) 17163 } 17164 } 17165 17166 func (s *Compound_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 17167 switch t := visitor.(type) { 17168 case ParserVisitor: 17169 return t.VisitCompound_operator(s) 17170 17171 default: 17172 return t.VisitChildren(s) 17173 } 17174 } 17175 17176 func (p *Parser) Compound_operator() (localctx ICompound_operatorContext) { 17177 this := p 17178 _ = this 17179 17180 localctx = NewCompound_operatorContext(p, p.GetParserRuleContext(), p.GetState()) 17181 p.EnterRule(localctx, 102, ParserRULE_compound_operator) 17182 var _la int 17183 17184 defer func() { 17185 p.ExitRule() 17186 }() 17187 17188 defer func() { 17189 if err := recover(); err != nil { 17190 if v, ok := err.(antlr.RecognitionException); ok { 17191 localctx.SetException(v) 17192 p.GetErrorHandler().ReportError(p, v) 17193 p.GetErrorHandler().Recover(p, v) 17194 } else { 17195 panic(err) 17196 } 17197 } 17198 }() 17199 17200 p.SetState(1535) 17201 p.GetErrorHandler().Sync(p) 17202 17203 switch p.GetTokenStream().LA(1) { 17204 case ParserUNION_: 17205 p.EnterOuterAlt(localctx, 1) 17206 { 17207 p.SetState(1529) 17208 p.Match(ParserUNION_) 17209 } 17210 p.SetState(1531) 17211 p.GetErrorHandler().Sync(p) 17212 _la = p.GetTokenStream().LA(1) 17213 17214 if _la == ParserALL_ { 17215 { 17216 p.SetState(1530) 17217 p.Match(ParserALL_) 17218 } 17219 17220 } 17221 17222 case ParserINTERSECT_: 17223 p.EnterOuterAlt(localctx, 2) 17224 { 17225 p.SetState(1533) 17226 p.Match(ParserINTERSECT_) 17227 } 17228 17229 case ParserEXCEPT_: 17230 p.EnterOuterAlt(localctx, 3) 17231 { 17232 p.SetState(1534) 17233 p.Match(ParserEXCEPT_) 17234 } 17235 17236 default: 17237 panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) 17238 } 17239 17240 return localctx 17241 } 17242 17243 // IUpdate_stmtContext is an interface to support dynamic dispatch. 17244 type IUpdate_stmtContext interface { 17245 antlr.ParserRuleContext 17246 17247 // GetParser returns the parser. 17248 GetParser() antlr.Parser 17249 17250 // GetWhere returns the where rule contexts. 17251 GetWhere() IExprContext 17252 17253 // SetWhere sets the where rule contexts. 17254 SetWhere(IExprContext) 17255 17256 // IsUpdate_stmtContext differentiates from other interfaces. 17257 IsUpdate_stmtContext() 17258 } 17259 17260 type Update_stmtContext struct { 17261 *antlr.BaseParserRuleContext 17262 parser antlr.Parser 17263 where IExprContext 17264 } 17265 17266 func NewEmptyUpdate_stmtContext() *Update_stmtContext { 17267 var p = new(Update_stmtContext) 17268 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 17269 p.RuleIndex = ParserRULE_update_stmt 17270 return p 17271 } 17272 17273 func (*Update_stmtContext) IsUpdate_stmtContext() {} 17274 17275 func NewUpdate_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_stmtContext { 17276 var p = new(Update_stmtContext) 17277 17278 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 17279 17280 p.parser = parser 17281 p.RuleIndex = ParserRULE_update_stmt 17282 17283 return p 17284 } 17285 17286 func (s *Update_stmtContext) GetParser() antlr.Parser { return s.parser } 17287 17288 func (s *Update_stmtContext) GetWhere() IExprContext { return s.where } 17289 17290 func (s *Update_stmtContext) SetWhere(v IExprContext) { s.where = v } 17291 17292 func (s *Update_stmtContext) UPDATE_() antlr.TerminalNode { 17293 return s.GetToken(ParserUPDATE_, 0) 17294 } 17295 17296 func (s *Update_stmtContext) Qualified_table_name() IQualified_table_nameContext { 17297 var t antlr.RuleContext 17298 for _, ctx := range s.GetChildren() { 17299 if _, ok := ctx.(IQualified_table_nameContext); ok { 17300 t = ctx.(antlr.RuleContext) 17301 break 17302 } 17303 } 17304 17305 if t == nil { 17306 return nil 17307 } 17308 17309 return t.(IQualified_table_nameContext) 17310 } 17311 17312 func (s *Update_stmtContext) SET_() antlr.TerminalNode { 17313 return s.GetToken(ParserSET_, 0) 17314 } 17315 17316 func (s *Update_stmtContext) Assignment_list() IAssignment_listContext { 17317 var t antlr.RuleContext 17318 for _, ctx := range s.GetChildren() { 17319 if _, ok := ctx.(IAssignment_listContext); ok { 17320 t = ctx.(antlr.RuleContext) 17321 break 17322 } 17323 } 17324 17325 if t == nil { 17326 return nil 17327 } 17328 17329 return t.(IAssignment_listContext) 17330 } 17331 17332 func (s *Update_stmtContext) With_clause() IWith_clauseContext { 17333 var t antlr.RuleContext 17334 for _, ctx := range s.GetChildren() { 17335 if _, ok := ctx.(IWith_clauseContext); ok { 17336 t = ctx.(antlr.RuleContext) 17337 break 17338 } 17339 } 17340 17341 if t == nil { 17342 return nil 17343 } 17344 17345 return t.(IWith_clauseContext) 17346 } 17347 17348 func (s *Update_stmtContext) OR_() antlr.TerminalNode { 17349 return s.GetToken(ParserOR_, 0) 17350 } 17351 17352 func (s *Update_stmtContext) FROM_() antlr.TerminalNode { 17353 return s.GetToken(ParserFROM_, 0) 17354 } 17355 17356 func (s *Update_stmtContext) WHERE_() antlr.TerminalNode { 17357 return s.GetToken(ParserWHERE_, 0) 17358 } 17359 17360 func (s *Update_stmtContext) Returning_clause() IReturning_clauseContext { 17361 var t antlr.RuleContext 17362 for _, ctx := range s.GetChildren() { 17363 if _, ok := ctx.(IReturning_clauseContext); ok { 17364 t = ctx.(antlr.RuleContext) 17365 break 17366 } 17367 } 17368 17369 if t == nil { 17370 return nil 17371 } 17372 17373 return t.(IReturning_clauseContext) 17374 } 17375 17376 func (s *Update_stmtContext) ROLLBACK_() antlr.TerminalNode { 17377 return s.GetToken(ParserROLLBACK_, 0) 17378 } 17379 17380 func (s *Update_stmtContext) ABORT_() antlr.TerminalNode { 17381 return s.GetToken(ParserABORT_, 0) 17382 } 17383 17384 func (s *Update_stmtContext) REPLACE_() antlr.TerminalNode { 17385 return s.GetToken(ParserREPLACE_, 0) 17386 } 17387 17388 func (s *Update_stmtContext) FAIL_() antlr.TerminalNode { 17389 return s.GetToken(ParserFAIL_, 0) 17390 } 17391 17392 func (s *Update_stmtContext) IGNORE_() antlr.TerminalNode { 17393 return s.GetToken(ParserIGNORE_, 0) 17394 } 17395 17396 func (s *Update_stmtContext) Expr() IExprContext { 17397 var t antlr.RuleContext 17398 for _, ctx := range s.GetChildren() { 17399 if _, ok := ctx.(IExprContext); ok { 17400 t = ctx.(antlr.RuleContext) 17401 break 17402 } 17403 } 17404 17405 if t == nil { 17406 return nil 17407 } 17408 17409 return t.(IExprContext) 17410 } 17411 17412 func (s *Update_stmtContext) AllTable_or_subquery() []ITable_or_subqueryContext { 17413 children := s.GetChildren() 17414 len := 0 17415 for _, ctx := range children { 17416 if _, ok := ctx.(ITable_or_subqueryContext); ok { 17417 len++ 17418 } 17419 } 17420 17421 tst := make([]ITable_or_subqueryContext, len) 17422 i := 0 17423 for _, ctx := range children { 17424 if t, ok := ctx.(ITable_or_subqueryContext); ok { 17425 tst[i] = t.(ITable_or_subqueryContext) 17426 i++ 17427 } 17428 } 17429 17430 return tst 17431 } 17432 17433 func (s *Update_stmtContext) Table_or_subquery(i int) ITable_or_subqueryContext { 17434 var t antlr.RuleContext 17435 j := 0 17436 for _, ctx := range s.GetChildren() { 17437 if _, ok := ctx.(ITable_or_subqueryContext); ok { 17438 if j == i { 17439 t = ctx.(antlr.RuleContext) 17440 break 17441 } 17442 j++ 17443 } 17444 } 17445 17446 if t == nil { 17447 return nil 17448 } 17449 17450 return t.(ITable_or_subqueryContext) 17451 } 17452 17453 func (s *Update_stmtContext) Join_clause() IJoin_clauseContext { 17454 var t antlr.RuleContext 17455 for _, ctx := range s.GetChildren() { 17456 if _, ok := ctx.(IJoin_clauseContext); ok { 17457 t = ctx.(antlr.RuleContext) 17458 break 17459 } 17460 } 17461 17462 if t == nil { 17463 return nil 17464 } 17465 17466 return t.(IJoin_clauseContext) 17467 } 17468 17469 func (s *Update_stmtContext) AllCOMMA() []antlr.TerminalNode { 17470 return s.GetTokens(ParserCOMMA) 17471 } 17472 17473 func (s *Update_stmtContext) COMMA(i int) antlr.TerminalNode { 17474 return s.GetToken(ParserCOMMA, i) 17475 } 17476 17477 func (s *Update_stmtContext) GetRuleContext() antlr.RuleContext { 17478 return s 17479 } 17480 17481 func (s *Update_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 17482 return antlr.TreesStringTree(s, ruleNames, recog) 17483 } 17484 17485 func (s *Update_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 17486 if listenerT, ok := listener.(ParserListener); ok { 17487 listenerT.EnterUpdate_stmt(s) 17488 } 17489 } 17490 17491 func (s *Update_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 17492 if listenerT, ok := listener.(ParserListener); ok { 17493 listenerT.ExitUpdate_stmt(s) 17494 } 17495 } 17496 17497 func (s *Update_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 17498 switch t := visitor.(type) { 17499 case ParserVisitor: 17500 return t.VisitUpdate_stmt(s) 17501 17502 default: 17503 return t.VisitChildren(s) 17504 } 17505 } 17506 17507 func (p *Parser) Update_stmt() (localctx IUpdate_stmtContext) { 17508 this := p 17509 _ = this 17510 17511 localctx = NewUpdate_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 17512 p.EnterRule(localctx, 104, ParserRULE_update_stmt) 17513 var _la int 17514 17515 defer func() { 17516 p.ExitRule() 17517 }() 17518 17519 defer func() { 17520 if err := recover(); err != nil { 17521 if v, ok := err.(antlr.RecognitionException); ok { 17522 localctx.SetException(v) 17523 p.GetErrorHandler().ReportError(p, v) 17524 p.GetErrorHandler().Recover(p, v) 17525 } else { 17526 panic(err) 17527 } 17528 } 17529 }() 17530 17531 p.EnterOuterAlt(localctx, 1) 17532 p.SetState(1538) 17533 p.GetErrorHandler().Sync(p) 17534 _la = p.GetTokenStream().LA(1) 17535 17536 if _la == ParserWITH_ { 17537 { 17538 p.SetState(1537) 17539 p.With_clause() 17540 } 17541 17542 } 17543 { 17544 p.SetState(1540) 17545 p.Match(ParserUPDATE_) 17546 } 17547 p.SetState(1543) 17548 p.GetErrorHandler().Sync(p) 17549 17550 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 221, p.GetParserRuleContext()) == 1 { 17551 { 17552 p.SetState(1541) 17553 p.Match(ParserOR_) 17554 } 17555 { 17556 p.SetState(1542) 17557 _la = p.GetTokenStream().LA(1) 17558 17559 if !(_la == ParserABORT_ || _la == ParserFAIL_ || _la == ParserIGNORE_ || _la == ParserREPLACE_ || _la == ParserROLLBACK_) { 17560 p.GetErrorHandler().RecoverInline(p) 17561 } else { 17562 p.GetErrorHandler().ReportMatch(p) 17563 p.Consume() 17564 } 17565 } 17566 17567 } 17568 { 17569 p.SetState(1545) 17570 p.Qualified_table_name() 17571 } 17572 { 17573 p.SetState(1546) 17574 p.Match(ParserSET_) 17575 } 17576 { 17577 p.SetState(1547) 17578 p.Assignment_list() 17579 } 17580 p.SetState(1560) 17581 p.GetErrorHandler().Sync(p) 17582 _la = p.GetTokenStream().LA(1) 17583 17584 if _la == ParserFROM_ { 17585 { 17586 p.SetState(1548) 17587 p.Match(ParserFROM_) 17588 } 17589 p.SetState(1558) 17590 p.GetErrorHandler().Sync(p) 17591 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 223, p.GetParserRuleContext()) { 17592 case 1: 17593 { 17594 p.SetState(1549) 17595 p.Table_or_subquery() 17596 } 17597 p.SetState(1554) 17598 p.GetErrorHandler().Sync(p) 17599 _la = p.GetTokenStream().LA(1) 17600 17601 for _la == ParserCOMMA { 17602 { 17603 p.SetState(1550) 17604 p.Match(ParserCOMMA) 17605 } 17606 { 17607 p.SetState(1551) 17608 p.Table_or_subquery() 17609 } 17610 17611 p.SetState(1556) 17612 p.GetErrorHandler().Sync(p) 17613 _la = p.GetTokenStream().LA(1) 17614 } 17615 17616 case 2: 17617 { 17618 p.SetState(1557) 17619 p.Join_clause() 17620 } 17621 17622 } 17623 17624 } 17625 p.SetState(1564) 17626 p.GetErrorHandler().Sync(p) 17627 _la = p.GetTokenStream().LA(1) 17628 17629 if _la == ParserWHERE_ { 17630 { 17631 p.SetState(1562) 17632 p.Match(ParserWHERE_) 17633 } 17634 { 17635 p.SetState(1563) 17636 17637 var _x = p.expr(0) 17638 17639 localctx.(*Update_stmtContext).where = _x 17640 } 17641 17642 } 17643 p.SetState(1567) 17644 p.GetErrorHandler().Sync(p) 17645 _la = p.GetTokenStream().LA(1) 17646 17647 if _la == ParserRETURNING_ { 17648 { 17649 p.SetState(1566) 17650 p.Returning_clause() 17651 } 17652 17653 } 17654 17655 return localctx 17656 } 17657 17658 // IAssignment_listContext is an interface to support dynamic dispatch. 17659 type IAssignment_listContext interface { 17660 antlr.ParserRuleContext 17661 17662 // GetParser returns the parser. 17663 GetParser() antlr.Parser 17664 17665 // IsAssignment_listContext differentiates from other interfaces. 17666 IsAssignment_listContext() 17667 } 17668 17669 type Assignment_listContext struct { 17670 *antlr.BaseParserRuleContext 17671 parser antlr.Parser 17672 } 17673 17674 func NewEmptyAssignment_listContext() *Assignment_listContext { 17675 var p = new(Assignment_listContext) 17676 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 17677 p.RuleIndex = ParserRULE_assignment_list 17678 return p 17679 } 17680 17681 func (*Assignment_listContext) IsAssignment_listContext() {} 17682 17683 func NewAssignment_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Assignment_listContext { 17684 var p = new(Assignment_listContext) 17685 17686 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 17687 17688 p.parser = parser 17689 p.RuleIndex = ParserRULE_assignment_list 17690 17691 return p 17692 } 17693 17694 func (s *Assignment_listContext) GetParser() antlr.Parser { return s.parser } 17695 17696 func (s *Assignment_listContext) AllAssignment() []IAssignmentContext { 17697 children := s.GetChildren() 17698 len := 0 17699 for _, ctx := range children { 17700 if _, ok := ctx.(IAssignmentContext); ok { 17701 len++ 17702 } 17703 } 17704 17705 tst := make([]IAssignmentContext, len) 17706 i := 0 17707 for _, ctx := range children { 17708 if t, ok := ctx.(IAssignmentContext); ok { 17709 tst[i] = t.(IAssignmentContext) 17710 i++ 17711 } 17712 } 17713 17714 return tst 17715 } 17716 17717 func (s *Assignment_listContext) Assignment(i int) IAssignmentContext { 17718 var t antlr.RuleContext 17719 j := 0 17720 for _, ctx := range s.GetChildren() { 17721 if _, ok := ctx.(IAssignmentContext); ok { 17722 if j == i { 17723 t = ctx.(antlr.RuleContext) 17724 break 17725 } 17726 j++ 17727 } 17728 } 17729 17730 if t == nil { 17731 return nil 17732 } 17733 17734 return t.(IAssignmentContext) 17735 } 17736 17737 func (s *Assignment_listContext) AllCOMMA() []antlr.TerminalNode { 17738 return s.GetTokens(ParserCOMMA) 17739 } 17740 17741 func (s *Assignment_listContext) COMMA(i int) antlr.TerminalNode { 17742 return s.GetToken(ParserCOMMA, i) 17743 } 17744 17745 func (s *Assignment_listContext) GetRuleContext() antlr.RuleContext { 17746 return s 17747 } 17748 17749 func (s *Assignment_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 17750 return antlr.TreesStringTree(s, ruleNames, recog) 17751 } 17752 17753 func (s *Assignment_listContext) EnterRule(listener antlr.ParseTreeListener) { 17754 if listenerT, ok := listener.(ParserListener); ok { 17755 listenerT.EnterAssignment_list(s) 17756 } 17757 } 17758 17759 func (s *Assignment_listContext) ExitRule(listener antlr.ParseTreeListener) { 17760 if listenerT, ok := listener.(ParserListener); ok { 17761 listenerT.ExitAssignment_list(s) 17762 } 17763 } 17764 17765 func (s *Assignment_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 17766 switch t := visitor.(type) { 17767 case ParserVisitor: 17768 return t.VisitAssignment_list(s) 17769 17770 default: 17771 return t.VisitChildren(s) 17772 } 17773 } 17774 17775 func (p *Parser) Assignment_list() (localctx IAssignment_listContext) { 17776 this := p 17777 _ = this 17778 17779 localctx = NewAssignment_listContext(p, p.GetParserRuleContext(), p.GetState()) 17780 p.EnterRule(localctx, 106, ParserRULE_assignment_list) 17781 var _la int 17782 17783 defer func() { 17784 p.ExitRule() 17785 }() 17786 17787 defer func() { 17788 if err := recover(); err != nil { 17789 if v, ok := err.(antlr.RecognitionException); ok { 17790 localctx.SetException(v) 17791 p.GetErrorHandler().ReportError(p, v) 17792 p.GetErrorHandler().Recover(p, v) 17793 } else { 17794 panic(err) 17795 } 17796 } 17797 }() 17798 17799 p.EnterOuterAlt(localctx, 1) 17800 { 17801 p.SetState(1569) 17802 p.Assignment() 17803 } 17804 p.SetState(1574) 17805 p.GetErrorHandler().Sync(p) 17806 _la = p.GetTokenStream().LA(1) 17807 17808 for _la == ParserCOMMA { 17809 { 17810 p.SetState(1570) 17811 p.Match(ParserCOMMA) 17812 } 17813 { 17814 p.SetState(1571) 17815 p.Assignment() 17816 } 17817 17818 p.SetState(1576) 17819 p.GetErrorHandler().Sync(p) 17820 _la = p.GetTokenStream().LA(1) 17821 } 17822 17823 return localctx 17824 } 17825 17826 // IAssignmentContext is an interface to support dynamic dispatch. 17827 type IAssignmentContext interface { 17828 antlr.ParserRuleContext 17829 17830 // GetParser returns the parser. 17831 GetParser() antlr.Parser 17832 17833 // IsAssignmentContext differentiates from other interfaces. 17834 IsAssignmentContext() 17835 } 17836 17837 type AssignmentContext struct { 17838 *antlr.BaseParserRuleContext 17839 parser antlr.Parser 17840 } 17841 17842 func NewEmptyAssignmentContext() *AssignmentContext { 17843 var p = new(AssignmentContext) 17844 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 17845 p.RuleIndex = ParserRULE_assignment 17846 return p 17847 } 17848 17849 func (*AssignmentContext) IsAssignmentContext() {} 17850 17851 func NewAssignmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentContext { 17852 var p = new(AssignmentContext) 17853 17854 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 17855 17856 p.parser = parser 17857 p.RuleIndex = ParserRULE_assignment 17858 17859 return p 17860 } 17861 17862 func (s *AssignmentContext) GetParser() antlr.Parser { return s.parser } 17863 17864 func (s *AssignmentContext) ASSIGN() antlr.TerminalNode { 17865 return s.GetToken(ParserASSIGN, 0) 17866 } 17867 17868 func (s *AssignmentContext) Expr() IExprContext { 17869 var t antlr.RuleContext 17870 for _, ctx := range s.GetChildren() { 17871 if _, ok := ctx.(IExprContext); ok { 17872 t = ctx.(antlr.RuleContext) 17873 break 17874 } 17875 } 17876 17877 if t == nil { 17878 return nil 17879 } 17880 17881 return t.(IExprContext) 17882 } 17883 17884 func (s *AssignmentContext) Column_name() IColumn_nameContext { 17885 var t antlr.RuleContext 17886 for _, ctx := range s.GetChildren() { 17887 if _, ok := ctx.(IColumn_nameContext); ok { 17888 t = ctx.(antlr.RuleContext) 17889 break 17890 } 17891 } 17892 17893 if t == nil { 17894 return nil 17895 } 17896 17897 return t.(IColumn_nameContext) 17898 } 17899 17900 func (s *AssignmentContext) Column_name_list() IColumn_name_listContext { 17901 var t antlr.RuleContext 17902 for _, ctx := range s.GetChildren() { 17903 if _, ok := ctx.(IColumn_name_listContext); ok { 17904 t = ctx.(antlr.RuleContext) 17905 break 17906 } 17907 } 17908 17909 if t == nil { 17910 return nil 17911 } 17912 17913 return t.(IColumn_name_listContext) 17914 } 17915 17916 func (s *AssignmentContext) GetRuleContext() antlr.RuleContext { 17917 return s 17918 } 17919 17920 func (s *AssignmentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 17921 return antlr.TreesStringTree(s, ruleNames, recog) 17922 } 17923 17924 func (s *AssignmentContext) EnterRule(listener antlr.ParseTreeListener) { 17925 if listenerT, ok := listener.(ParserListener); ok { 17926 listenerT.EnterAssignment(s) 17927 } 17928 } 17929 17930 func (s *AssignmentContext) ExitRule(listener antlr.ParseTreeListener) { 17931 if listenerT, ok := listener.(ParserListener); ok { 17932 listenerT.ExitAssignment(s) 17933 } 17934 } 17935 17936 func (s *AssignmentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 17937 switch t := visitor.(type) { 17938 case ParserVisitor: 17939 return t.VisitAssignment(s) 17940 17941 default: 17942 return t.VisitChildren(s) 17943 } 17944 } 17945 17946 func (p *Parser) Assignment() (localctx IAssignmentContext) { 17947 this := p 17948 _ = this 17949 17950 localctx = NewAssignmentContext(p, p.GetParserRuleContext(), p.GetState()) 17951 p.EnterRule(localctx, 108, ParserRULE_assignment) 17952 17953 defer func() { 17954 p.ExitRule() 17955 }() 17956 17957 defer func() { 17958 if err := recover(); err != nil { 17959 if v, ok := err.(antlr.RecognitionException); ok { 17960 localctx.SetException(v) 17961 p.GetErrorHandler().ReportError(p, v) 17962 p.GetErrorHandler().Recover(p, v) 17963 } else { 17964 panic(err) 17965 } 17966 } 17967 }() 17968 17969 p.EnterOuterAlt(localctx, 1) 17970 p.SetState(1579) 17971 p.GetErrorHandler().Sync(p) 17972 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 228, p.GetParserRuleContext()) { 17973 case 1: 17974 { 17975 p.SetState(1577) 17976 p.Column_name() 17977 } 17978 17979 case 2: 17980 { 17981 p.SetState(1578) 17982 p.Column_name_list() 17983 } 17984 17985 } 17986 { 17987 p.SetState(1581) 17988 p.Match(ParserASSIGN) 17989 } 17990 { 17991 p.SetState(1582) 17992 p.expr(0) 17993 } 17994 17995 return localctx 17996 } 17997 17998 // IColumn_name_listContext is an interface to support dynamic dispatch. 17999 type IColumn_name_listContext interface { 18000 antlr.ParserRuleContext 18001 18002 // GetParser returns the parser. 18003 GetParser() antlr.Parser 18004 18005 // IsColumn_name_listContext differentiates from other interfaces. 18006 IsColumn_name_listContext() 18007 } 18008 18009 type Column_name_listContext struct { 18010 *antlr.BaseParserRuleContext 18011 parser antlr.Parser 18012 } 18013 18014 func NewEmptyColumn_name_listContext() *Column_name_listContext { 18015 var p = new(Column_name_listContext) 18016 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 18017 p.RuleIndex = ParserRULE_column_name_list 18018 return p 18019 } 18020 18021 func (*Column_name_listContext) IsColumn_name_listContext() {} 18022 18023 func NewColumn_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_name_listContext { 18024 var p = new(Column_name_listContext) 18025 18026 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 18027 18028 p.parser = parser 18029 p.RuleIndex = ParserRULE_column_name_list 18030 18031 return p 18032 } 18033 18034 func (s *Column_name_listContext) GetParser() antlr.Parser { return s.parser } 18035 18036 func (s *Column_name_listContext) OPEN_PAR() antlr.TerminalNode { 18037 return s.GetToken(ParserOPEN_PAR, 0) 18038 } 18039 18040 func (s *Column_name_listContext) AllColumn_name() []IColumn_nameContext { 18041 children := s.GetChildren() 18042 len := 0 18043 for _, ctx := range children { 18044 if _, ok := ctx.(IColumn_nameContext); ok { 18045 len++ 18046 } 18047 } 18048 18049 tst := make([]IColumn_nameContext, len) 18050 i := 0 18051 for _, ctx := range children { 18052 if t, ok := ctx.(IColumn_nameContext); ok { 18053 tst[i] = t.(IColumn_nameContext) 18054 i++ 18055 } 18056 } 18057 18058 return tst 18059 } 18060 18061 func (s *Column_name_listContext) Column_name(i int) IColumn_nameContext { 18062 var t antlr.RuleContext 18063 j := 0 18064 for _, ctx := range s.GetChildren() { 18065 if _, ok := ctx.(IColumn_nameContext); ok { 18066 if j == i { 18067 t = ctx.(antlr.RuleContext) 18068 break 18069 } 18070 j++ 18071 } 18072 } 18073 18074 if t == nil { 18075 return nil 18076 } 18077 18078 return t.(IColumn_nameContext) 18079 } 18080 18081 func (s *Column_name_listContext) CLOSE_PAR() antlr.TerminalNode { 18082 return s.GetToken(ParserCLOSE_PAR, 0) 18083 } 18084 18085 func (s *Column_name_listContext) AllCOMMA() []antlr.TerminalNode { 18086 return s.GetTokens(ParserCOMMA) 18087 } 18088 18089 func (s *Column_name_listContext) COMMA(i int) antlr.TerminalNode { 18090 return s.GetToken(ParserCOMMA, i) 18091 } 18092 18093 func (s *Column_name_listContext) GetRuleContext() antlr.RuleContext { 18094 return s 18095 } 18096 18097 func (s *Column_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 18098 return antlr.TreesStringTree(s, ruleNames, recog) 18099 } 18100 18101 func (s *Column_name_listContext) EnterRule(listener antlr.ParseTreeListener) { 18102 if listenerT, ok := listener.(ParserListener); ok { 18103 listenerT.EnterColumn_name_list(s) 18104 } 18105 } 18106 18107 func (s *Column_name_listContext) ExitRule(listener antlr.ParseTreeListener) { 18108 if listenerT, ok := listener.(ParserListener); ok { 18109 listenerT.ExitColumn_name_list(s) 18110 } 18111 } 18112 18113 func (s *Column_name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 18114 switch t := visitor.(type) { 18115 case ParserVisitor: 18116 return t.VisitColumn_name_list(s) 18117 18118 default: 18119 return t.VisitChildren(s) 18120 } 18121 } 18122 18123 func (p *Parser) Column_name_list() (localctx IColumn_name_listContext) { 18124 this := p 18125 _ = this 18126 18127 localctx = NewColumn_name_listContext(p, p.GetParserRuleContext(), p.GetState()) 18128 p.EnterRule(localctx, 110, ParserRULE_column_name_list) 18129 var _la int 18130 18131 defer func() { 18132 p.ExitRule() 18133 }() 18134 18135 defer func() { 18136 if err := recover(); err != nil { 18137 if v, ok := err.(antlr.RecognitionException); ok { 18138 localctx.SetException(v) 18139 p.GetErrorHandler().ReportError(p, v) 18140 p.GetErrorHandler().Recover(p, v) 18141 } else { 18142 panic(err) 18143 } 18144 } 18145 }() 18146 18147 p.EnterOuterAlt(localctx, 1) 18148 { 18149 p.SetState(1584) 18150 p.Match(ParserOPEN_PAR) 18151 } 18152 { 18153 p.SetState(1585) 18154 p.Column_name() 18155 } 18156 p.SetState(1590) 18157 p.GetErrorHandler().Sync(p) 18158 _la = p.GetTokenStream().LA(1) 18159 18160 for _la == ParserCOMMA { 18161 { 18162 p.SetState(1586) 18163 p.Match(ParserCOMMA) 18164 } 18165 { 18166 p.SetState(1587) 18167 p.Column_name() 18168 } 18169 18170 p.SetState(1592) 18171 p.GetErrorHandler().Sync(p) 18172 _la = p.GetTokenStream().LA(1) 18173 } 18174 { 18175 p.SetState(1593) 18176 p.Match(ParserCLOSE_PAR) 18177 } 18178 18179 return localctx 18180 } 18181 18182 // IUpdate_stmt_limitedContext is an interface to support dynamic dispatch. 18183 type IUpdate_stmt_limitedContext interface { 18184 antlr.ParserRuleContext 18185 18186 // GetParser returns the parser. 18187 GetParser() antlr.Parser 18188 18189 // IsUpdate_stmt_limitedContext differentiates from other interfaces. 18190 IsUpdate_stmt_limitedContext() 18191 } 18192 18193 type Update_stmt_limitedContext struct { 18194 *antlr.BaseParserRuleContext 18195 parser antlr.Parser 18196 } 18197 18198 func NewEmptyUpdate_stmt_limitedContext() *Update_stmt_limitedContext { 18199 var p = new(Update_stmt_limitedContext) 18200 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 18201 p.RuleIndex = ParserRULE_update_stmt_limited 18202 return p 18203 } 18204 18205 func (*Update_stmt_limitedContext) IsUpdate_stmt_limitedContext() {} 18206 18207 func NewUpdate_stmt_limitedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_stmt_limitedContext { 18208 var p = new(Update_stmt_limitedContext) 18209 18210 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 18211 18212 p.parser = parser 18213 p.RuleIndex = ParserRULE_update_stmt_limited 18214 18215 return p 18216 } 18217 18218 func (s *Update_stmt_limitedContext) GetParser() antlr.Parser { return s.parser } 18219 18220 func (s *Update_stmt_limitedContext) UPDATE_() antlr.TerminalNode { 18221 return s.GetToken(ParserUPDATE_, 0) 18222 } 18223 18224 func (s *Update_stmt_limitedContext) Qualified_table_name() IQualified_table_nameContext { 18225 var t antlr.RuleContext 18226 for _, ctx := range s.GetChildren() { 18227 if _, ok := ctx.(IQualified_table_nameContext); ok { 18228 t = ctx.(antlr.RuleContext) 18229 break 18230 } 18231 } 18232 18233 if t == nil { 18234 return nil 18235 } 18236 18237 return t.(IQualified_table_nameContext) 18238 } 18239 18240 func (s *Update_stmt_limitedContext) SET_() antlr.TerminalNode { 18241 return s.GetToken(ParserSET_, 0) 18242 } 18243 18244 func (s *Update_stmt_limitedContext) AllASSIGN() []antlr.TerminalNode { 18245 return s.GetTokens(ParserASSIGN) 18246 } 18247 18248 func (s *Update_stmt_limitedContext) ASSIGN(i int) antlr.TerminalNode { 18249 return s.GetToken(ParserASSIGN, i) 18250 } 18251 18252 func (s *Update_stmt_limitedContext) AllExpr() []IExprContext { 18253 children := s.GetChildren() 18254 len := 0 18255 for _, ctx := range children { 18256 if _, ok := ctx.(IExprContext); ok { 18257 len++ 18258 } 18259 } 18260 18261 tst := make([]IExprContext, len) 18262 i := 0 18263 for _, ctx := range children { 18264 if t, ok := ctx.(IExprContext); ok { 18265 tst[i] = t.(IExprContext) 18266 i++ 18267 } 18268 } 18269 18270 return tst 18271 } 18272 18273 func (s *Update_stmt_limitedContext) Expr(i int) IExprContext { 18274 var t antlr.RuleContext 18275 j := 0 18276 for _, ctx := range s.GetChildren() { 18277 if _, ok := ctx.(IExprContext); ok { 18278 if j == i { 18279 t = ctx.(antlr.RuleContext) 18280 break 18281 } 18282 j++ 18283 } 18284 } 18285 18286 if t == nil { 18287 return nil 18288 } 18289 18290 return t.(IExprContext) 18291 } 18292 18293 func (s *Update_stmt_limitedContext) AllColumn_name() []IColumn_nameContext { 18294 children := s.GetChildren() 18295 len := 0 18296 for _, ctx := range children { 18297 if _, ok := ctx.(IColumn_nameContext); ok { 18298 len++ 18299 } 18300 } 18301 18302 tst := make([]IColumn_nameContext, len) 18303 i := 0 18304 for _, ctx := range children { 18305 if t, ok := ctx.(IColumn_nameContext); ok { 18306 tst[i] = t.(IColumn_nameContext) 18307 i++ 18308 } 18309 } 18310 18311 return tst 18312 } 18313 18314 func (s *Update_stmt_limitedContext) Column_name(i int) IColumn_nameContext { 18315 var t antlr.RuleContext 18316 j := 0 18317 for _, ctx := range s.GetChildren() { 18318 if _, ok := ctx.(IColumn_nameContext); ok { 18319 if j == i { 18320 t = ctx.(antlr.RuleContext) 18321 break 18322 } 18323 j++ 18324 } 18325 } 18326 18327 if t == nil { 18328 return nil 18329 } 18330 18331 return t.(IColumn_nameContext) 18332 } 18333 18334 func (s *Update_stmt_limitedContext) AllColumn_name_list() []IColumn_name_listContext { 18335 children := s.GetChildren() 18336 len := 0 18337 for _, ctx := range children { 18338 if _, ok := ctx.(IColumn_name_listContext); ok { 18339 len++ 18340 } 18341 } 18342 18343 tst := make([]IColumn_name_listContext, len) 18344 i := 0 18345 for _, ctx := range children { 18346 if t, ok := ctx.(IColumn_name_listContext); ok { 18347 tst[i] = t.(IColumn_name_listContext) 18348 i++ 18349 } 18350 } 18351 18352 return tst 18353 } 18354 18355 func (s *Update_stmt_limitedContext) Column_name_list(i int) IColumn_name_listContext { 18356 var t antlr.RuleContext 18357 j := 0 18358 for _, ctx := range s.GetChildren() { 18359 if _, ok := ctx.(IColumn_name_listContext); ok { 18360 if j == i { 18361 t = ctx.(antlr.RuleContext) 18362 break 18363 } 18364 j++ 18365 } 18366 } 18367 18368 if t == nil { 18369 return nil 18370 } 18371 18372 return t.(IColumn_name_listContext) 18373 } 18374 18375 func (s *Update_stmt_limitedContext) With_clause() IWith_clauseContext { 18376 var t antlr.RuleContext 18377 for _, ctx := range s.GetChildren() { 18378 if _, ok := ctx.(IWith_clauseContext); ok { 18379 t = ctx.(antlr.RuleContext) 18380 break 18381 } 18382 } 18383 18384 if t == nil { 18385 return nil 18386 } 18387 18388 return t.(IWith_clauseContext) 18389 } 18390 18391 func (s *Update_stmt_limitedContext) OR_() antlr.TerminalNode { 18392 return s.GetToken(ParserOR_, 0) 18393 } 18394 18395 func (s *Update_stmt_limitedContext) AllCOMMA() []antlr.TerminalNode { 18396 return s.GetTokens(ParserCOMMA) 18397 } 18398 18399 func (s *Update_stmt_limitedContext) COMMA(i int) antlr.TerminalNode { 18400 return s.GetToken(ParserCOMMA, i) 18401 } 18402 18403 func (s *Update_stmt_limitedContext) WHERE_() antlr.TerminalNode { 18404 return s.GetToken(ParserWHERE_, 0) 18405 } 18406 18407 func (s *Update_stmt_limitedContext) Returning_clause() IReturning_clauseContext { 18408 var t antlr.RuleContext 18409 for _, ctx := range s.GetChildren() { 18410 if _, ok := ctx.(IReturning_clauseContext); ok { 18411 t = ctx.(antlr.RuleContext) 18412 break 18413 } 18414 } 18415 18416 if t == nil { 18417 return nil 18418 } 18419 18420 return t.(IReturning_clauseContext) 18421 } 18422 18423 func (s *Update_stmt_limitedContext) Limit_stmt() ILimit_stmtContext { 18424 var t antlr.RuleContext 18425 for _, ctx := range s.GetChildren() { 18426 if _, ok := ctx.(ILimit_stmtContext); ok { 18427 t = ctx.(antlr.RuleContext) 18428 break 18429 } 18430 } 18431 18432 if t == nil { 18433 return nil 18434 } 18435 18436 return t.(ILimit_stmtContext) 18437 } 18438 18439 func (s *Update_stmt_limitedContext) ROLLBACK_() antlr.TerminalNode { 18440 return s.GetToken(ParserROLLBACK_, 0) 18441 } 18442 18443 func (s *Update_stmt_limitedContext) ABORT_() antlr.TerminalNode { 18444 return s.GetToken(ParserABORT_, 0) 18445 } 18446 18447 func (s *Update_stmt_limitedContext) REPLACE_() antlr.TerminalNode { 18448 return s.GetToken(ParserREPLACE_, 0) 18449 } 18450 18451 func (s *Update_stmt_limitedContext) FAIL_() antlr.TerminalNode { 18452 return s.GetToken(ParserFAIL_, 0) 18453 } 18454 18455 func (s *Update_stmt_limitedContext) IGNORE_() antlr.TerminalNode { 18456 return s.GetToken(ParserIGNORE_, 0) 18457 } 18458 18459 func (s *Update_stmt_limitedContext) Order_by_stmt() IOrder_by_stmtContext { 18460 var t antlr.RuleContext 18461 for _, ctx := range s.GetChildren() { 18462 if _, ok := ctx.(IOrder_by_stmtContext); ok { 18463 t = ctx.(antlr.RuleContext) 18464 break 18465 } 18466 } 18467 18468 if t == nil { 18469 return nil 18470 } 18471 18472 return t.(IOrder_by_stmtContext) 18473 } 18474 18475 func (s *Update_stmt_limitedContext) GetRuleContext() antlr.RuleContext { 18476 return s 18477 } 18478 18479 func (s *Update_stmt_limitedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 18480 return antlr.TreesStringTree(s, ruleNames, recog) 18481 } 18482 18483 func (s *Update_stmt_limitedContext) EnterRule(listener antlr.ParseTreeListener) { 18484 if listenerT, ok := listener.(ParserListener); ok { 18485 listenerT.EnterUpdate_stmt_limited(s) 18486 } 18487 } 18488 18489 func (s *Update_stmt_limitedContext) ExitRule(listener antlr.ParseTreeListener) { 18490 if listenerT, ok := listener.(ParserListener); ok { 18491 listenerT.ExitUpdate_stmt_limited(s) 18492 } 18493 } 18494 18495 func (s *Update_stmt_limitedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 18496 switch t := visitor.(type) { 18497 case ParserVisitor: 18498 return t.VisitUpdate_stmt_limited(s) 18499 18500 default: 18501 return t.VisitChildren(s) 18502 } 18503 } 18504 18505 func (p *Parser) Update_stmt_limited() (localctx IUpdate_stmt_limitedContext) { 18506 this := p 18507 _ = this 18508 18509 localctx = NewUpdate_stmt_limitedContext(p, p.GetParserRuleContext(), p.GetState()) 18510 p.EnterRule(localctx, 112, ParserRULE_update_stmt_limited) 18511 var _la int 18512 18513 defer func() { 18514 p.ExitRule() 18515 }() 18516 18517 defer func() { 18518 if err := recover(); err != nil { 18519 if v, ok := err.(antlr.RecognitionException); ok { 18520 localctx.SetException(v) 18521 p.GetErrorHandler().ReportError(p, v) 18522 p.GetErrorHandler().Recover(p, v) 18523 } else { 18524 panic(err) 18525 } 18526 } 18527 }() 18528 18529 p.EnterOuterAlt(localctx, 1) 18530 p.SetState(1596) 18531 p.GetErrorHandler().Sync(p) 18532 _la = p.GetTokenStream().LA(1) 18533 18534 if _la == ParserWITH_ { 18535 { 18536 p.SetState(1595) 18537 p.With_clause() 18538 } 18539 18540 } 18541 { 18542 p.SetState(1598) 18543 p.Match(ParserUPDATE_) 18544 } 18545 p.SetState(1601) 18546 p.GetErrorHandler().Sync(p) 18547 18548 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 231, p.GetParserRuleContext()) == 1 { 18549 { 18550 p.SetState(1599) 18551 p.Match(ParserOR_) 18552 } 18553 { 18554 p.SetState(1600) 18555 _la = p.GetTokenStream().LA(1) 18556 18557 if !(_la == ParserABORT_ || _la == ParserFAIL_ || _la == ParserIGNORE_ || _la == ParserREPLACE_ || _la == ParserROLLBACK_) { 18558 p.GetErrorHandler().RecoverInline(p) 18559 } else { 18560 p.GetErrorHandler().ReportMatch(p) 18561 p.Consume() 18562 } 18563 } 18564 18565 } 18566 { 18567 p.SetState(1603) 18568 p.Qualified_table_name() 18569 } 18570 { 18571 p.SetState(1604) 18572 p.Match(ParserSET_) 18573 } 18574 p.SetState(1607) 18575 p.GetErrorHandler().Sync(p) 18576 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 232, p.GetParserRuleContext()) { 18577 case 1: 18578 { 18579 p.SetState(1605) 18580 p.Column_name() 18581 } 18582 18583 case 2: 18584 { 18585 p.SetState(1606) 18586 p.Column_name_list() 18587 } 18588 18589 } 18590 { 18591 p.SetState(1609) 18592 p.Match(ParserASSIGN) 18593 } 18594 { 18595 p.SetState(1610) 18596 p.expr(0) 18597 } 18598 p.SetState(1621) 18599 p.GetErrorHandler().Sync(p) 18600 _la = p.GetTokenStream().LA(1) 18601 18602 for _la == ParserCOMMA { 18603 { 18604 p.SetState(1611) 18605 p.Match(ParserCOMMA) 18606 } 18607 p.SetState(1614) 18608 p.GetErrorHandler().Sync(p) 18609 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 233, p.GetParserRuleContext()) { 18610 case 1: 18611 { 18612 p.SetState(1612) 18613 p.Column_name() 18614 } 18615 18616 case 2: 18617 { 18618 p.SetState(1613) 18619 p.Column_name_list() 18620 } 18621 18622 } 18623 { 18624 p.SetState(1616) 18625 p.Match(ParserASSIGN) 18626 } 18627 { 18628 p.SetState(1617) 18629 p.expr(0) 18630 } 18631 18632 p.SetState(1623) 18633 p.GetErrorHandler().Sync(p) 18634 _la = p.GetTokenStream().LA(1) 18635 } 18636 p.SetState(1626) 18637 p.GetErrorHandler().Sync(p) 18638 _la = p.GetTokenStream().LA(1) 18639 18640 if _la == ParserWHERE_ { 18641 { 18642 p.SetState(1624) 18643 p.Match(ParserWHERE_) 18644 } 18645 { 18646 p.SetState(1625) 18647 p.expr(0) 18648 } 18649 18650 } 18651 p.SetState(1629) 18652 p.GetErrorHandler().Sync(p) 18653 _la = p.GetTokenStream().LA(1) 18654 18655 if _la == ParserRETURNING_ { 18656 { 18657 p.SetState(1628) 18658 p.Returning_clause() 18659 } 18660 18661 } 18662 p.SetState(1635) 18663 p.GetErrorHandler().Sync(p) 18664 _la = p.GetTokenStream().LA(1) 18665 18666 if _la == ParserLIMIT_ || _la == ParserORDER_ { 18667 p.SetState(1632) 18668 p.GetErrorHandler().Sync(p) 18669 _la = p.GetTokenStream().LA(1) 18670 18671 if _la == ParserORDER_ { 18672 { 18673 p.SetState(1631) 18674 p.Order_by_stmt() 18675 } 18676 18677 } 18678 { 18679 p.SetState(1634) 18680 p.Limit_stmt() 18681 } 18682 18683 } 18684 18685 return localctx 18686 } 18687 18688 // IQualified_table_nameContext is an interface to support dynamic dispatch. 18689 type IQualified_table_nameContext interface { 18690 antlr.ParserRuleContext 18691 18692 // GetParser returns the parser. 18693 GetParser() antlr.Parser 18694 18695 // IsQualified_table_nameContext differentiates from other interfaces. 18696 IsQualified_table_nameContext() 18697 } 18698 18699 type Qualified_table_nameContext struct { 18700 *antlr.BaseParserRuleContext 18701 parser antlr.Parser 18702 } 18703 18704 func NewEmptyQualified_table_nameContext() *Qualified_table_nameContext { 18705 var p = new(Qualified_table_nameContext) 18706 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 18707 p.RuleIndex = ParserRULE_qualified_table_name 18708 return p 18709 } 18710 18711 func (*Qualified_table_nameContext) IsQualified_table_nameContext() {} 18712 18713 func NewQualified_table_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qualified_table_nameContext { 18714 var p = new(Qualified_table_nameContext) 18715 18716 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 18717 18718 p.parser = parser 18719 p.RuleIndex = ParserRULE_qualified_table_name 18720 18721 return p 18722 } 18723 18724 func (s *Qualified_table_nameContext) GetParser() antlr.Parser { return s.parser } 18725 18726 func (s *Qualified_table_nameContext) Table_name() ITable_nameContext { 18727 var t antlr.RuleContext 18728 for _, ctx := range s.GetChildren() { 18729 if _, ok := ctx.(ITable_nameContext); ok { 18730 t = ctx.(antlr.RuleContext) 18731 break 18732 } 18733 } 18734 18735 if t == nil { 18736 return nil 18737 } 18738 18739 return t.(ITable_nameContext) 18740 } 18741 18742 func (s *Qualified_table_nameContext) Schema_name() ISchema_nameContext { 18743 var t antlr.RuleContext 18744 for _, ctx := range s.GetChildren() { 18745 if _, ok := ctx.(ISchema_nameContext); ok { 18746 t = ctx.(antlr.RuleContext) 18747 break 18748 } 18749 } 18750 18751 if t == nil { 18752 return nil 18753 } 18754 18755 return t.(ISchema_nameContext) 18756 } 18757 18758 func (s *Qualified_table_nameContext) DOT() antlr.TerminalNode { 18759 return s.GetToken(ParserDOT, 0) 18760 } 18761 18762 func (s *Qualified_table_nameContext) AS_() antlr.TerminalNode { 18763 return s.GetToken(ParserAS_, 0) 18764 } 18765 18766 func (s *Qualified_table_nameContext) Alias() IAliasContext { 18767 var t antlr.RuleContext 18768 for _, ctx := range s.GetChildren() { 18769 if _, ok := ctx.(IAliasContext); ok { 18770 t = ctx.(antlr.RuleContext) 18771 break 18772 } 18773 } 18774 18775 if t == nil { 18776 return nil 18777 } 18778 18779 return t.(IAliasContext) 18780 } 18781 18782 func (s *Qualified_table_nameContext) INDEXED_() antlr.TerminalNode { 18783 return s.GetToken(ParserINDEXED_, 0) 18784 } 18785 18786 func (s *Qualified_table_nameContext) BY_() antlr.TerminalNode { 18787 return s.GetToken(ParserBY_, 0) 18788 } 18789 18790 func (s *Qualified_table_nameContext) Index_name() IIndex_nameContext { 18791 var t antlr.RuleContext 18792 for _, ctx := range s.GetChildren() { 18793 if _, ok := ctx.(IIndex_nameContext); ok { 18794 t = ctx.(antlr.RuleContext) 18795 break 18796 } 18797 } 18798 18799 if t == nil { 18800 return nil 18801 } 18802 18803 return t.(IIndex_nameContext) 18804 } 18805 18806 func (s *Qualified_table_nameContext) NOT_() antlr.TerminalNode { 18807 return s.GetToken(ParserNOT_, 0) 18808 } 18809 18810 func (s *Qualified_table_nameContext) GetRuleContext() antlr.RuleContext { 18811 return s 18812 } 18813 18814 func (s *Qualified_table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 18815 return antlr.TreesStringTree(s, ruleNames, recog) 18816 } 18817 18818 func (s *Qualified_table_nameContext) EnterRule(listener antlr.ParseTreeListener) { 18819 if listenerT, ok := listener.(ParserListener); ok { 18820 listenerT.EnterQualified_table_name(s) 18821 } 18822 } 18823 18824 func (s *Qualified_table_nameContext) ExitRule(listener antlr.ParseTreeListener) { 18825 if listenerT, ok := listener.(ParserListener); ok { 18826 listenerT.ExitQualified_table_name(s) 18827 } 18828 } 18829 18830 func (s *Qualified_table_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 18831 switch t := visitor.(type) { 18832 case ParserVisitor: 18833 return t.VisitQualified_table_name(s) 18834 18835 default: 18836 return t.VisitChildren(s) 18837 } 18838 } 18839 18840 func (p *Parser) Qualified_table_name() (localctx IQualified_table_nameContext) { 18841 this := p 18842 _ = this 18843 18844 localctx = NewQualified_table_nameContext(p, p.GetParserRuleContext(), p.GetState()) 18845 p.EnterRule(localctx, 114, ParserRULE_qualified_table_name) 18846 var _la int 18847 18848 defer func() { 18849 p.ExitRule() 18850 }() 18851 18852 defer func() { 18853 if err := recover(); err != nil { 18854 if v, ok := err.(antlr.RecognitionException); ok { 18855 localctx.SetException(v) 18856 p.GetErrorHandler().ReportError(p, v) 18857 p.GetErrorHandler().Recover(p, v) 18858 } else { 18859 panic(err) 18860 } 18861 } 18862 }() 18863 18864 p.EnterOuterAlt(localctx, 1) 18865 p.SetState(1640) 18866 p.GetErrorHandler().Sync(p) 18867 18868 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 239, p.GetParserRuleContext()) == 1 { 18869 { 18870 p.SetState(1637) 18871 p.Schema_name() 18872 } 18873 { 18874 p.SetState(1638) 18875 p.Match(ParserDOT) 18876 } 18877 18878 } 18879 { 18880 p.SetState(1642) 18881 p.Table_name() 18882 } 18883 p.SetState(1645) 18884 p.GetErrorHandler().Sync(p) 18885 _la = p.GetTokenStream().LA(1) 18886 18887 if _la == ParserAS_ { 18888 { 18889 p.SetState(1643) 18890 p.Match(ParserAS_) 18891 } 18892 { 18893 p.SetState(1644) 18894 p.Alias() 18895 } 18896 18897 } 18898 p.SetState(1652) 18899 p.GetErrorHandler().Sync(p) 18900 18901 switch p.GetTokenStream().LA(1) { 18902 case ParserINDEXED_: 18903 { 18904 p.SetState(1647) 18905 p.Match(ParserINDEXED_) 18906 } 18907 { 18908 p.SetState(1648) 18909 p.Match(ParserBY_) 18910 } 18911 { 18912 p.SetState(1649) 18913 p.Index_name() 18914 } 18915 18916 case ParserNOT_: 18917 { 18918 p.SetState(1650) 18919 p.Match(ParserNOT_) 18920 } 18921 { 18922 p.SetState(1651) 18923 p.Match(ParserINDEXED_) 18924 } 18925 18926 case ParserEOF, ParserSCOL, ParserALTER_, ParserANALYZE_, ParserATTACH_, ParserBEGIN_, ParserCOMMIT_, ParserCREATE_, ParserDELETE_, ParserDETACH_, ParserDROP_, ParserEND_, ParserEXPLAIN_, ParserINSERT_, ParserLIMIT_, ParserORDER_, ParserPRAGMA_, ParserREINDEX_, ParserRELEASE_, ParserREPLACE_, ParserRETURNING_, ParserROLLBACK_, ParserSAVEPOINT_, ParserSELECT_, ParserSET_, ParserUPDATE_, ParserVACUUM_, ParserVALUES_, ParserWHERE_, ParserWITH_: 18927 18928 default: 18929 } 18930 18931 return localctx 18932 } 18933 18934 // IVacuum_stmtContext is an interface to support dynamic dispatch. 18935 type IVacuum_stmtContext interface { 18936 antlr.ParserRuleContext 18937 18938 // GetParser returns the parser. 18939 GetParser() antlr.Parser 18940 18941 // IsVacuum_stmtContext differentiates from other interfaces. 18942 IsVacuum_stmtContext() 18943 } 18944 18945 type Vacuum_stmtContext struct { 18946 *antlr.BaseParserRuleContext 18947 parser antlr.Parser 18948 } 18949 18950 func NewEmptyVacuum_stmtContext() *Vacuum_stmtContext { 18951 var p = new(Vacuum_stmtContext) 18952 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 18953 p.RuleIndex = ParserRULE_vacuum_stmt 18954 return p 18955 } 18956 18957 func (*Vacuum_stmtContext) IsVacuum_stmtContext() {} 18958 18959 func NewVacuum_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Vacuum_stmtContext { 18960 var p = new(Vacuum_stmtContext) 18961 18962 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 18963 18964 p.parser = parser 18965 p.RuleIndex = ParserRULE_vacuum_stmt 18966 18967 return p 18968 } 18969 18970 func (s *Vacuum_stmtContext) GetParser() antlr.Parser { return s.parser } 18971 18972 func (s *Vacuum_stmtContext) VACUUM_() antlr.TerminalNode { 18973 return s.GetToken(ParserVACUUM_, 0) 18974 } 18975 18976 func (s *Vacuum_stmtContext) Schema_name() ISchema_nameContext { 18977 var t antlr.RuleContext 18978 for _, ctx := range s.GetChildren() { 18979 if _, ok := ctx.(ISchema_nameContext); ok { 18980 t = ctx.(antlr.RuleContext) 18981 break 18982 } 18983 } 18984 18985 if t == nil { 18986 return nil 18987 } 18988 18989 return t.(ISchema_nameContext) 18990 } 18991 18992 func (s *Vacuum_stmtContext) INTO_() antlr.TerminalNode { 18993 return s.GetToken(ParserINTO_, 0) 18994 } 18995 18996 func (s *Vacuum_stmtContext) Filename() IFilenameContext { 18997 var t antlr.RuleContext 18998 for _, ctx := range s.GetChildren() { 18999 if _, ok := ctx.(IFilenameContext); ok { 19000 t = ctx.(antlr.RuleContext) 19001 break 19002 } 19003 } 19004 19005 if t == nil { 19006 return nil 19007 } 19008 19009 return t.(IFilenameContext) 19010 } 19011 19012 func (s *Vacuum_stmtContext) GetRuleContext() antlr.RuleContext { 19013 return s 19014 } 19015 19016 func (s *Vacuum_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 19017 return antlr.TreesStringTree(s, ruleNames, recog) 19018 } 19019 19020 func (s *Vacuum_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 19021 if listenerT, ok := listener.(ParserListener); ok { 19022 listenerT.EnterVacuum_stmt(s) 19023 } 19024 } 19025 19026 func (s *Vacuum_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 19027 if listenerT, ok := listener.(ParserListener); ok { 19028 listenerT.ExitVacuum_stmt(s) 19029 } 19030 } 19031 19032 func (s *Vacuum_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 19033 switch t := visitor.(type) { 19034 case ParserVisitor: 19035 return t.VisitVacuum_stmt(s) 19036 19037 default: 19038 return t.VisitChildren(s) 19039 } 19040 } 19041 19042 func (p *Parser) Vacuum_stmt() (localctx IVacuum_stmtContext) { 19043 this := p 19044 _ = this 19045 19046 localctx = NewVacuum_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 19047 p.EnterRule(localctx, 116, ParserRULE_vacuum_stmt) 19048 var _la int 19049 19050 defer func() { 19051 p.ExitRule() 19052 }() 19053 19054 defer func() { 19055 if err := recover(); err != nil { 19056 if v, ok := err.(antlr.RecognitionException); ok { 19057 localctx.SetException(v) 19058 p.GetErrorHandler().ReportError(p, v) 19059 p.GetErrorHandler().Recover(p, v) 19060 } else { 19061 panic(err) 19062 } 19063 } 19064 }() 19065 19066 p.EnterOuterAlt(localctx, 1) 19067 { 19068 p.SetState(1654) 19069 p.Match(ParserVACUUM_) 19070 } 19071 p.SetState(1656) 19072 p.GetErrorHandler().Sync(p) 19073 19074 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 242, p.GetParserRuleContext()) == 1 { 19075 { 19076 p.SetState(1655) 19077 p.Schema_name() 19078 } 19079 19080 } 19081 p.SetState(1660) 19082 p.GetErrorHandler().Sync(p) 19083 _la = p.GetTokenStream().LA(1) 19084 19085 if _la == ParserINTO_ { 19086 { 19087 p.SetState(1658) 19088 p.Match(ParserINTO_) 19089 } 19090 { 19091 p.SetState(1659) 19092 p.Filename() 19093 } 19094 19095 } 19096 19097 return localctx 19098 } 19099 19100 // IFilter_clauseContext is an interface to support dynamic dispatch. 19101 type IFilter_clauseContext interface { 19102 antlr.ParserRuleContext 19103 19104 // GetParser returns the parser. 19105 GetParser() antlr.Parser 19106 19107 // IsFilter_clauseContext differentiates from other interfaces. 19108 IsFilter_clauseContext() 19109 } 19110 19111 type Filter_clauseContext struct { 19112 *antlr.BaseParserRuleContext 19113 parser antlr.Parser 19114 } 19115 19116 func NewEmptyFilter_clauseContext() *Filter_clauseContext { 19117 var p = new(Filter_clauseContext) 19118 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 19119 p.RuleIndex = ParserRULE_filter_clause 19120 return p 19121 } 19122 19123 func (*Filter_clauseContext) IsFilter_clauseContext() {} 19124 19125 func NewFilter_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Filter_clauseContext { 19126 var p = new(Filter_clauseContext) 19127 19128 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 19129 19130 p.parser = parser 19131 p.RuleIndex = ParserRULE_filter_clause 19132 19133 return p 19134 } 19135 19136 func (s *Filter_clauseContext) GetParser() antlr.Parser { return s.parser } 19137 19138 func (s *Filter_clauseContext) FILTER_() antlr.TerminalNode { 19139 return s.GetToken(ParserFILTER_, 0) 19140 } 19141 19142 func (s *Filter_clauseContext) OPEN_PAR() antlr.TerminalNode { 19143 return s.GetToken(ParserOPEN_PAR, 0) 19144 } 19145 19146 func (s *Filter_clauseContext) WHERE_() antlr.TerminalNode { 19147 return s.GetToken(ParserWHERE_, 0) 19148 } 19149 19150 func (s *Filter_clauseContext) Expr() IExprContext { 19151 var t antlr.RuleContext 19152 for _, ctx := range s.GetChildren() { 19153 if _, ok := ctx.(IExprContext); ok { 19154 t = ctx.(antlr.RuleContext) 19155 break 19156 } 19157 } 19158 19159 if t == nil { 19160 return nil 19161 } 19162 19163 return t.(IExprContext) 19164 } 19165 19166 func (s *Filter_clauseContext) CLOSE_PAR() antlr.TerminalNode { 19167 return s.GetToken(ParserCLOSE_PAR, 0) 19168 } 19169 19170 func (s *Filter_clauseContext) GetRuleContext() antlr.RuleContext { 19171 return s 19172 } 19173 19174 func (s *Filter_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 19175 return antlr.TreesStringTree(s, ruleNames, recog) 19176 } 19177 19178 func (s *Filter_clauseContext) EnterRule(listener antlr.ParseTreeListener) { 19179 if listenerT, ok := listener.(ParserListener); ok { 19180 listenerT.EnterFilter_clause(s) 19181 } 19182 } 19183 19184 func (s *Filter_clauseContext) ExitRule(listener antlr.ParseTreeListener) { 19185 if listenerT, ok := listener.(ParserListener); ok { 19186 listenerT.ExitFilter_clause(s) 19187 } 19188 } 19189 19190 func (s *Filter_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 19191 switch t := visitor.(type) { 19192 case ParserVisitor: 19193 return t.VisitFilter_clause(s) 19194 19195 default: 19196 return t.VisitChildren(s) 19197 } 19198 } 19199 19200 func (p *Parser) Filter_clause() (localctx IFilter_clauseContext) { 19201 this := p 19202 _ = this 19203 19204 localctx = NewFilter_clauseContext(p, p.GetParserRuleContext(), p.GetState()) 19205 p.EnterRule(localctx, 118, ParserRULE_filter_clause) 19206 19207 defer func() { 19208 p.ExitRule() 19209 }() 19210 19211 defer func() { 19212 if err := recover(); err != nil { 19213 if v, ok := err.(antlr.RecognitionException); ok { 19214 localctx.SetException(v) 19215 p.GetErrorHandler().ReportError(p, v) 19216 p.GetErrorHandler().Recover(p, v) 19217 } else { 19218 panic(err) 19219 } 19220 } 19221 }() 19222 19223 p.EnterOuterAlt(localctx, 1) 19224 { 19225 p.SetState(1662) 19226 p.Match(ParserFILTER_) 19227 } 19228 { 19229 p.SetState(1663) 19230 p.Match(ParserOPEN_PAR) 19231 } 19232 { 19233 p.SetState(1664) 19234 p.Match(ParserWHERE_) 19235 } 19236 { 19237 p.SetState(1665) 19238 p.expr(0) 19239 } 19240 { 19241 p.SetState(1666) 19242 p.Match(ParserCLOSE_PAR) 19243 } 19244 19245 return localctx 19246 } 19247 19248 // IWindow_defnContext is an interface to support dynamic dispatch. 19249 type IWindow_defnContext interface { 19250 antlr.ParserRuleContext 19251 19252 // GetParser returns the parser. 19253 GetParser() antlr.Parser 19254 19255 // IsWindow_defnContext differentiates from other interfaces. 19256 IsWindow_defnContext() 19257 } 19258 19259 type Window_defnContext struct { 19260 *antlr.BaseParserRuleContext 19261 parser antlr.Parser 19262 } 19263 19264 func NewEmptyWindow_defnContext() *Window_defnContext { 19265 var p = new(Window_defnContext) 19266 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 19267 p.RuleIndex = ParserRULE_window_defn 19268 return p 19269 } 19270 19271 func (*Window_defnContext) IsWindow_defnContext() {} 19272 19273 func NewWindow_defnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_defnContext { 19274 var p = new(Window_defnContext) 19275 19276 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 19277 19278 p.parser = parser 19279 p.RuleIndex = ParserRULE_window_defn 19280 19281 return p 19282 } 19283 19284 func (s *Window_defnContext) GetParser() antlr.Parser { return s.parser } 19285 19286 func (s *Window_defnContext) OPEN_PAR() antlr.TerminalNode { 19287 return s.GetToken(ParserOPEN_PAR, 0) 19288 } 19289 19290 func (s *Window_defnContext) CLOSE_PAR() antlr.TerminalNode { 19291 return s.GetToken(ParserCLOSE_PAR, 0) 19292 } 19293 19294 func (s *Window_defnContext) ORDER_() antlr.TerminalNode { 19295 return s.GetToken(ParserORDER_, 0) 19296 } 19297 19298 func (s *Window_defnContext) AllBY_() []antlr.TerminalNode { 19299 return s.GetTokens(ParserBY_) 19300 } 19301 19302 func (s *Window_defnContext) BY_(i int) antlr.TerminalNode { 19303 return s.GetToken(ParserBY_, i) 19304 } 19305 19306 func (s *Window_defnContext) AllOrdering_term() []IOrdering_termContext { 19307 children := s.GetChildren() 19308 len := 0 19309 for _, ctx := range children { 19310 if _, ok := ctx.(IOrdering_termContext); ok { 19311 len++ 19312 } 19313 } 19314 19315 tst := make([]IOrdering_termContext, len) 19316 i := 0 19317 for _, ctx := range children { 19318 if t, ok := ctx.(IOrdering_termContext); ok { 19319 tst[i] = t.(IOrdering_termContext) 19320 i++ 19321 } 19322 } 19323 19324 return tst 19325 } 19326 19327 func (s *Window_defnContext) Ordering_term(i int) IOrdering_termContext { 19328 var t antlr.RuleContext 19329 j := 0 19330 for _, ctx := range s.GetChildren() { 19331 if _, ok := ctx.(IOrdering_termContext); ok { 19332 if j == i { 19333 t = ctx.(antlr.RuleContext) 19334 break 19335 } 19336 j++ 19337 } 19338 } 19339 19340 if t == nil { 19341 return nil 19342 } 19343 19344 return t.(IOrdering_termContext) 19345 } 19346 19347 func (s *Window_defnContext) Base_window_name() IBase_window_nameContext { 19348 var t antlr.RuleContext 19349 for _, ctx := range s.GetChildren() { 19350 if _, ok := ctx.(IBase_window_nameContext); ok { 19351 t = ctx.(antlr.RuleContext) 19352 break 19353 } 19354 } 19355 19356 if t == nil { 19357 return nil 19358 } 19359 19360 return t.(IBase_window_nameContext) 19361 } 19362 19363 func (s *Window_defnContext) PARTITION_() antlr.TerminalNode { 19364 return s.GetToken(ParserPARTITION_, 0) 19365 } 19366 19367 func (s *Window_defnContext) AllExpr() []IExprContext { 19368 children := s.GetChildren() 19369 len := 0 19370 for _, ctx := range children { 19371 if _, ok := ctx.(IExprContext); ok { 19372 len++ 19373 } 19374 } 19375 19376 tst := make([]IExprContext, len) 19377 i := 0 19378 for _, ctx := range children { 19379 if t, ok := ctx.(IExprContext); ok { 19380 tst[i] = t.(IExprContext) 19381 i++ 19382 } 19383 } 19384 19385 return tst 19386 } 19387 19388 func (s *Window_defnContext) Expr(i int) IExprContext { 19389 var t antlr.RuleContext 19390 j := 0 19391 for _, ctx := range s.GetChildren() { 19392 if _, ok := ctx.(IExprContext); ok { 19393 if j == i { 19394 t = ctx.(antlr.RuleContext) 19395 break 19396 } 19397 j++ 19398 } 19399 } 19400 19401 if t == nil { 19402 return nil 19403 } 19404 19405 return t.(IExprContext) 19406 } 19407 19408 func (s *Window_defnContext) Frame_spec() IFrame_specContext { 19409 var t antlr.RuleContext 19410 for _, ctx := range s.GetChildren() { 19411 if _, ok := ctx.(IFrame_specContext); ok { 19412 t = ctx.(antlr.RuleContext) 19413 break 19414 } 19415 } 19416 19417 if t == nil { 19418 return nil 19419 } 19420 19421 return t.(IFrame_specContext) 19422 } 19423 19424 func (s *Window_defnContext) AllCOMMA() []antlr.TerminalNode { 19425 return s.GetTokens(ParserCOMMA) 19426 } 19427 19428 func (s *Window_defnContext) COMMA(i int) antlr.TerminalNode { 19429 return s.GetToken(ParserCOMMA, i) 19430 } 19431 19432 func (s *Window_defnContext) GetRuleContext() antlr.RuleContext { 19433 return s 19434 } 19435 19436 func (s *Window_defnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 19437 return antlr.TreesStringTree(s, ruleNames, recog) 19438 } 19439 19440 func (s *Window_defnContext) EnterRule(listener antlr.ParseTreeListener) { 19441 if listenerT, ok := listener.(ParserListener); ok { 19442 listenerT.EnterWindow_defn(s) 19443 } 19444 } 19445 19446 func (s *Window_defnContext) ExitRule(listener antlr.ParseTreeListener) { 19447 if listenerT, ok := listener.(ParserListener); ok { 19448 listenerT.ExitWindow_defn(s) 19449 } 19450 } 19451 19452 func (s *Window_defnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 19453 switch t := visitor.(type) { 19454 case ParserVisitor: 19455 return t.VisitWindow_defn(s) 19456 19457 default: 19458 return t.VisitChildren(s) 19459 } 19460 } 19461 19462 func (p *Parser) Window_defn() (localctx IWindow_defnContext) { 19463 this := p 19464 _ = this 19465 19466 localctx = NewWindow_defnContext(p, p.GetParserRuleContext(), p.GetState()) 19467 p.EnterRule(localctx, 120, ParserRULE_window_defn) 19468 var _la int 19469 19470 defer func() { 19471 p.ExitRule() 19472 }() 19473 19474 defer func() { 19475 if err := recover(); err != nil { 19476 if v, ok := err.(antlr.RecognitionException); ok { 19477 localctx.SetException(v) 19478 p.GetErrorHandler().ReportError(p, v) 19479 p.GetErrorHandler().Recover(p, v) 19480 } else { 19481 panic(err) 19482 } 19483 } 19484 }() 19485 19486 p.EnterOuterAlt(localctx, 1) 19487 { 19488 p.SetState(1668) 19489 p.Match(ParserOPEN_PAR) 19490 } 19491 p.SetState(1670) 19492 p.GetErrorHandler().Sync(p) 19493 19494 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 244, p.GetParserRuleContext()) == 1 { 19495 { 19496 p.SetState(1669) 19497 p.Base_window_name() 19498 } 19499 19500 } 19501 p.SetState(1682) 19502 p.GetErrorHandler().Sync(p) 19503 _la = p.GetTokenStream().LA(1) 19504 19505 if _la == ParserPARTITION_ { 19506 { 19507 p.SetState(1672) 19508 p.Match(ParserPARTITION_) 19509 } 19510 { 19511 p.SetState(1673) 19512 p.Match(ParserBY_) 19513 } 19514 { 19515 p.SetState(1674) 19516 p.expr(0) 19517 } 19518 p.SetState(1679) 19519 p.GetErrorHandler().Sync(p) 19520 _la = p.GetTokenStream().LA(1) 19521 19522 for _la == ParserCOMMA { 19523 { 19524 p.SetState(1675) 19525 p.Match(ParserCOMMA) 19526 } 19527 { 19528 p.SetState(1676) 19529 p.expr(0) 19530 } 19531 19532 p.SetState(1681) 19533 p.GetErrorHandler().Sync(p) 19534 _la = p.GetTokenStream().LA(1) 19535 } 19536 19537 } 19538 19539 { 19540 p.SetState(1684) 19541 p.Match(ParserORDER_) 19542 } 19543 { 19544 p.SetState(1685) 19545 p.Match(ParserBY_) 19546 } 19547 { 19548 p.SetState(1686) 19549 p.Ordering_term() 19550 } 19551 p.SetState(1691) 19552 p.GetErrorHandler().Sync(p) 19553 _la = p.GetTokenStream().LA(1) 19554 19555 for _la == ParserCOMMA { 19556 { 19557 p.SetState(1687) 19558 p.Match(ParserCOMMA) 19559 } 19560 { 19561 p.SetState(1688) 19562 p.Ordering_term() 19563 } 19564 19565 p.SetState(1693) 19566 p.GetErrorHandler().Sync(p) 19567 _la = p.GetTokenStream().LA(1) 19568 } 19569 19570 p.SetState(1695) 19571 p.GetErrorHandler().Sync(p) 19572 _la = p.GetTokenStream().LA(1) 19573 19574 if _la == ParserROWS_ || _la == ParserRANGE_ || _la == ParserGROUPS_ { 19575 { 19576 p.SetState(1694) 19577 p.Frame_spec() 19578 } 19579 19580 } 19581 { 19582 p.SetState(1697) 19583 p.Match(ParserCLOSE_PAR) 19584 } 19585 19586 return localctx 19587 } 19588 19589 // IOver_clauseContext is an interface to support dynamic dispatch. 19590 type IOver_clauseContext interface { 19591 antlr.ParserRuleContext 19592 19593 // GetParser returns the parser. 19594 GetParser() antlr.Parser 19595 19596 // IsOver_clauseContext differentiates from other interfaces. 19597 IsOver_clauseContext() 19598 } 19599 19600 type Over_clauseContext struct { 19601 *antlr.BaseParserRuleContext 19602 parser antlr.Parser 19603 } 19604 19605 func NewEmptyOver_clauseContext() *Over_clauseContext { 19606 var p = new(Over_clauseContext) 19607 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 19608 p.RuleIndex = ParserRULE_over_clause 19609 return p 19610 } 19611 19612 func (*Over_clauseContext) IsOver_clauseContext() {} 19613 19614 func NewOver_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Over_clauseContext { 19615 var p = new(Over_clauseContext) 19616 19617 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 19618 19619 p.parser = parser 19620 p.RuleIndex = ParserRULE_over_clause 19621 19622 return p 19623 } 19624 19625 func (s *Over_clauseContext) GetParser() antlr.Parser { return s.parser } 19626 19627 func (s *Over_clauseContext) OVER_() antlr.TerminalNode { 19628 return s.GetToken(ParserOVER_, 0) 19629 } 19630 19631 func (s *Over_clauseContext) Window_name() IWindow_nameContext { 19632 var t antlr.RuleContext 19633 for _, ctx := range s.GetChildren() { 19634 if _, ok := ctx.(IWindow_nameContext); ok { 19635 t = ctx.(antlr.RuleContext) 19636 break 19637 } 19638 } 19639 19640 if t == nil { 19641 return nil 19642 } 19643 19644 return t.(IWindow_nameContext) 19645 } 19646 19647 func (s *Over_clauseContext) OPEN_PAR() antlr.TerminalNode { 19648 return s.GetToken(ParserOPEN_PAR, 0) 19649 } 19650 19651 func (s *Over_clauseContext) CLOSE_PAR() antlr.TerminalNode { 19652 return s.GetToken(ParserCLOSE_PAR, 0) 19653 } 19654 19655 func (s *Over_clauseContext) Base_window_name() IBase_window_nameContext { 19656 var t antlr.RuleContext 19657 for _, ctx := range s.GetChildren() { 19658 if _, ok := ctx.(IBase_window_nameContext); ok { 19659 t = ctx.(antlr.RuleContext) 19660 break 19661 } 19662 } 19663 19664 if t == nil { 19665 return nil 19666 } 19667 19668 return t.(IBase_window_nameContext) 19669 } 19670 19671 func (s *Over_clauseContext) PARTITION_() antlr.TerminalNode { 19672 return s.GetToken(ParserPARTITION_, 0) 19673 } 19674 19675 func (s *Over_clauseContext) AllBY_() []antlr.TerminalNode { 19676 return s.GetTokens(ParserBY_) 19677 } 19678 19679 func (s *Over_clauseContext) BY_(i int) antlr.TerminalNode { 19680 return s.GetToken(ParserBY_, i) 19681 } 19682 19683 func (s *Over_clauseContext) AllExpr() []IExprContext { 19684 children := s.GetChildren() 19685 len := 0 19686 for _, ctx := range children { 19687 if _, ok := ctx.(IExprContext); ok { 19688 len++ 19689 } 19690 } 19691 19692 tst := make([]IExprContext, len) 19693 i := 0 19694 for _, ctx := range children { 19695 if t, ok := ctx.(IExprContext); ok { 19696 tst[i] = t.(IExprContext) 19697 i++ 19698 } 19699 } 19700 19701 return tst 19702 } 19703 19704 func (s *Over_clauseContext) Expr(i int) IExprContext { 19705 var t antlr.RuleContext 19706 j := 0 19707 for _, ctx := range s.GetChildren() { 19708 if _, ok := ctx.(IExprContext); ok { 19709 if j == i { 19710 t = ctx.(antlr.RuleContext) 19711 break 19712 } 19713 j++ 19714 } 19715 } 19716 19717 if t == nil { 19718 return nil 19719 } 19720 19721 return t.(IExprContext) 19722 } 19723 19724 func (s *Over_clauseContext) ORDER_() antlr.TerminalNode { 19725 return s.GetToken(ParserORDER_, 0) 19726 } 19727 19728 func (s *Over_clauseContext) AllOrdering_term() []IOrdering_termContext { 19729 children := s.GetChildren() 19730 len := 0 19731 for _, ctx := range children { 19732 if _, ok := ctx.(IOrdering_termContext); ok { 19733 len++ 19734 } 19735 } 19736 19737 tst := make([]IOrdering_termContext, len) 19738 i := 0 19739 for _, ctx := range children { 19740 if t, ok := ctx.(IOrdering_termContext); ok { 19741 tst[i] = t.(IOrdering_termContext) 19742 i++ 19743 } 19744 } 19745 19746 return tst 19747 } 19748 19749 func (s *Over_clauseContext) Ordering_term(i int) IOrdering_termContext { 19750 var t antlr.RuleContext 19751 j := 0 19752 for _, ctx := range s.GetChildren() { 19753 if _, ok := ctx.(IOrdering_termContext); ok { 19754 if j == i { 19755 t = ctx.(antlr.RuleContext) 19756 break 19757 } 19758 j++ 19759 } 19760 } 19761 19762 if t == nil { 19763 return nil 19764 } 19765 19766 return t.(IOrdering_termContext) 19767 } 19768 19769 func (s *Over_clauseContext) Frame_spec() IFrame_specContext { 19770 var t antlr.RuleContext 19771 for _, ctx := range s.GetChildren() { 19772 if _, ok := ctx.(IFrame_specContext); ok { 19773 t = ctx.(antlr.RuleContext) 19774 break 19775 } 19776 } 19777 19778 if t == nil { 19779 return nil 19780 } 19781 19782 return t.(IFrame_specContext) 19783 } 19784 19785 func (s *Over_clauseContext) AllCOMMA() []antlr.TerminalNode { 19786 return s.GetTokens(ParserCOMMA) 19787 } 19788 19789 func (s *Over_clauseContext) COMMA(i int) antlr.TerminalNode { 19790 return s.GetToken(ParserCOMMA, i) 19791 } 19792 19793 func (s *Over_clauseContext) GetRuleContext() antlr.RuleContext { 19794 return s 19795 } 19796 19797 func (s *Over_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 19798 return antlr.TreesStringTree(s, ruleNames, recog) 19799 } 19800 19801 func (s *Over_clauseContext) EnterRule(listener antlr.ParseTreeListener) { 19802 if listenerT, ok := listener.(ParserListener); ok { 19803 listenerT.EnterOver_clause(s) 19804 } 19805 } 19806 19807 func (s *Over_clauseContext) ExitRule(listener antlr.ParseTreeListener) { 19808 if listenerT, ok := listener.(ParserListener); ok { 19809 listenerT.ExitOver_clause(s) 19810 } 19811 } 19812 19813 func (s *Over_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 19814 switch t := visitor.(type) { 19815 case ParserVisitor: 19816 return t.VisitOver_clause(s) 19817 19818 default: 19819 return t.VisitChildren(s) 19820 } 19821 } 19822 19823 func (p *Parser) Over_clause() (localctx IOver_clauseContext) { 19824 this := p 19825 _ = this 19826 19827 localctx = NewOver_clauseContext(p, p.GetParserRuleContext(), p.GetState()) 19828 p.EnterRule(localctx, 122, ParserRULE_over_clause) 19829 var _la int 19830 19831 defer func() { 19832 p.ExitRule() 19833 }() 19834 19835 defer func() { 19836 if err := recover(); err != nil { 19837 if v, ok := err.(antlr.RecognitionException); ok { 19838 localctx.SetException(v) 19839 p.GetErrorHandler().ReportError(p, v) 19840 p.GetErrorHandler().Recover(p, v) 19841 } else { 19842 panic(err) 19843 } 19844 } 19845 }() 19846 19847 p.EnterOuterAlt(localctx, 1) 19848 { 19849 p.SetState(1699) 19850 p.Match(ParserOVER_) 19851 } 19852 p.SetState(1733) 19853 p.GetErrorHandler().Sync(p) 19854 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 255, p.GetParserRuleContext()) { 19855 case 1: 19856 { 19857 p.SetState(1700) 19858 p.Window_name() 19859 } 19860 19861 case 2: 19862 { 19863 p.SetState(1701) 19864 p.Match(ParserOPEN_PAR) 19865 } 19866 p.SetState(1703) 19867 p.GetErrorHandler().Sync(p) 19868 19869 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 249, p.GetParserRuleContext()) == 1 { 19870 { 19871 p.SetState(1702) 19872 p.Base_window_name() 19873 } 19874 19875 } 19876 p.SetState(1715) 19877 p.GetErrorHandler().Sync(p) 19878 _la = p.GetTokenStream().LA(1) 19879 19880 if _la == ParserPARTITION_ { 19881 { 19882 p.SetState(1705) 19883 p.Match(ParserPARTITION_) 19884 } 19885 { 19886 p.SetState(1706) 19887 p.Match(ParserBY_) 19888 } 19889 { 19890 p.SetState(1707) 19891 p.expr(0) 19892 } 19893 p.SetState(1712) 19894 p.GetErrorHandler().Sync(p) 19895 _la = p.GetTokenStream().LA(1) 19896 19897 for _la == ParserCOMMA { 19898 { 19899 p.SetState(1708) 19900 p.Match(ParserCOMMA) 19901 } 19902 { 19903 p.SetState(1709) 19904 p.expr(0) 19905 } 19906 19907 p.SetState(1714) 19908 p.GetErrorHandler().Sync(p) 19909 _la = p.GetTokenStream().LA(1) 19910 } 19911 19912 } 19913 p.SetState(1727) 19914 p.GetErrorHandler().Sync(p) 19915 _la = p.GetTokenStream().LA(1) 19916 19917 if _la == ParserORDER_ { 19918 { 19919 p.SetState(1717) 19920 p.Match(ParserORDER_) 19921 } 19922 { 19923 p.SetState(1718) 19924 p.Match(ParserBY_) 19925 } 19926 { 19927 p.SetState(1719) 19928 p.Ordering_term() 19929 } 19930 p.SetState(1724) 19931 p.GetErrorHandler().Sync(p) 19932 _la = p.GetTokenStream().LA(1) 19933 19934 for _la == ParserCOMMA { 19935 { 19936 p.SetState(1720) 19937 p.Match(ParserCOMMA) 19938 } 19939 { 19940 p.SetState(1721) 19941 p.Ordering_term() 19942 } 19943 19944 p.SetState(1726) 19945 p.GetErrorHandler().Sync(p) 19946 _la = p.GetTokenStream().LA(1) 19947 } 19948 19949 } 19950 p.SetState(1730) 19951 p.GetErrorHandler().Sync(p) 19952 _la = p.GetTokenStream().LA(1) 19953 19954 if _la == ParserROWS_ || _la == ParserRANGE_ || _la == ParserGROUPS_ { 19955 { 19956 p.SetState(1729) 19957 p.Frame_spec() 19958 } 19959 19960 } 19961 { 19962 p.SetState(1732) 19963 p.Match(ParserCLOSE_PAR) 19964 } 19965 19966 } 19967 19968 return localctx 19969 } 19970 19971 // IFrame_specContext is an interface to support dynamic dispatch. 19972 type IFrame_specContext interface { 19973 antlr.ParserRuleContext 19974 19975 // GetParser returns the parser. 19976 GetParser() antlr.Parser 19977 19978 // IsFrame_specContext differentiates from other interfaces. 19979 IsFrame_specContext() 19980 } 19981 19982 type Frame_specContext struct { 19983 *antlr.BaseParserRuleContext 19984 parser antlr.Parser 19985 } 19986 19987 func NewEmptyFrame_specContext() *Frame_specContext { 19988 var p = new(Frame_specContext) 19989 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 19990 p.RuleIndex = ParserRULE_frame_spec 19991 return p 19992 } 19993 19994 func (*Frame_specContext) IsFrame_specContext() {} 19995 19996 func NewFrame_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Frame_specContext { 19997 var p = new(Frame_specContext) 19998 19999 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 20000 20001 p.parser = parser 20002 p.RuleIndex = ParserRULE_frame_spec 20003 20004 return p 20005 } 20006 20007 func (s *Frame_specContext) GetParser() antlr.Parser { return s.parser } 20008 20009 func (s *Frame_specContext) Frame_clause() IFrame_clauseContext { 20010 var t antlr.RuleContext 20011 for _, ctx := range s.GetChildren() { 20012 if _, ok := ctx.(IFrame_clauseContext); ok { 20013 t = ctx.(antlr.RuleContext) 20014 break 20015 } 20016 } 20017 20018 if t == nil { 20019 return nil 20020 } 20021 20022 return t.(IFrame_clauseContext) 20023 } 20024 20025 func (s *Frame_specContext) EXCLUDE_() antlr.TerminalNode { 20026 return s.GetToken(ParserEXCLUDE_, 0) 20027 } 20028 20029 func (s *Frame_specContext) CURRENT_() antlr.TerminalNode { 20030 return s.GetToken(ParserCURRENT_, 0) 20031 } 20032 20033 func (s *Frame_specContext) ROW_() antlr.TerminalNode { 20034 return s.GetToken(ParserROW_, 0) 20035 } 20036 20037 func (s *Frame_specContext) GROUP_() antlr.TerminalNode { 20038 return s.GetToken(ParserGROUP_, 0) 20039 } 20040 20041 func (s *Frame_specContext) TIES_() antlr.TerminalNode { 20042 return s.GetToken(ParserTIES_, 0) 20043 } 20044 20045 func (s *Frame_specContext) NO_() antlr.TerminalNode { 20046 return s.GetToken(ParserNO_, 0) 20047 } 20048 20049 func (s *Frame_specContext) OTHERS_() antlr.TerminalNode { 20050 return s.GetToken(ParserOTHERS_, 0) 20051 } 20052 20053 func (s *Frame_specContext) GetRuleContext() antlr.RuleContext { 20054 return s 20055 } 20056 20057 func (s *Frame_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 20058 return antlr.TreesStringTree(s, ruleNames, recog) 20059 } 20060 20061 func (s *Frame_specContext) EnterRule(listener antlr.ParseTreeListener) { 20062 if listenerT, ok := listener.(ParserListener); ok { 20063 listenerT.EnterFrame_spec(s) 20064 } 20065 } 20066 20067 func (s *Frame_specContext) ExitRule(listener antlr.ParseTreeListener) { 20068 if listenerT, ok := listener.(ParserListener); ok { 20069 listenerT.ExitFrame_spec(s) 20070 } 20071 } 20072 20073 func (s *Frame_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 20074 switch t := visitor.(type) { 20075 case ParserVisitor: 20076 return t.VisitFrame_spec(s) 20077 20078 default: 20079 return t.VisitChildren(s) 20080 } 20081 } 20082 20083 func (p *Parser) Frame_spec() (localctx IFrame_specContext) { 20084 this := p 20085 _ = this 20086 20087 localctx = NewFrame_specContext(p, p.GetParserRuleContext(), p.GetState()) 20088 p.EnterRule(localctx, 124, ParserRULE_frame_spec) 20089 20090 defer func() { 20091 p.ExitRule() 20092 }() 20093 20094 defer func() { 20095 if err := recover(); err != nil { 20096 if v, ok := err.(antlr.RecognitionException); ok { 20097 localctx.SetException(v) 20098 p.GetErrorHandler().ReportError(p, v) 20099 p.GetErrorHandler().Recover(p, v) 20100 } else { 20101 panic(err) 20102 } 20103 } 20104 }() 20105 20106 p.EnterOuterAlt(localctx, 1) 20107 { 20108 p.SetState(1735) 20109 p.Frame_clause() 20110 } 20111 p.SetState(1743) 20112 p.GetErrorHandler().Sync(p) 20113 20114 switch p.GetTokenStream().LA(1) { 20115 case ParserEXCLUDE_: 20116 { 20117 p.SetState(1736) 20118 p.Match(ParserEXCLUDE_) 20119 } 20120 20121 { 20122 p.SetState(1737) 20123 p.Match(ParserNO_) 20124 } 20125 { 20126 p.SetState(1738) 20127 p.Match(ParserOTHERS_) 20128 } 20129 20130 case ParserCURRENT_: 20131 { 20132 p.SetState(1739) 20133 p.Match(ParserCURRENT_) 20134 } 20135 { 20136 p.SetState(1740) 20137 p.Match(ParserROW_) 20138 } 20139 20140 case ParserGROUP_: 20141 { 20142 p.SetState(1741) 20143 p.Match(ParserGROUP_) 20144 } 20145 20146 case ParserTIES_: 20147 { 20148 p.SetState(1742) 20149 p.Match(ParserTIES_) 20150 } 20151 20152 case ParserCLOSE_PAR: 20153 20154 default: 20155 } 20156 20157 return localctx 20158 } 20159 20160 // IFrame_clauseContext is an interface to support dynamic dispatch. 20161 type IFrame_clauseContext interface { 20162 antlr.ParserRuleContext 20163 20164 // GetParser returns the parser. 20165 GetParser() antlr.Parser 20166 20167 // IsFrame_clauseContext differentiates from other interfaces. 20168 IsFrame_clauseContext() 20169 } 20170 20171 type Frame_clauseContext struct { 20172 *antlr.BaseParserRuleContext 20173 parser antlr.Parser 20174 } 20175 20176 func NewEmptyFrame_clauseContext() *Frame_clauseContext { 20177 var p = new(Frame_clauseContext) 20178 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 20179 p.RuleIndex = ParserRULE_frame_clause 20180 return p 20181 } 20182 20183 func (*Frame_clauseContext) IsFrame_clauseContext() {} 20184 20185 func NewFrame_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Frame_clauseContext { 20186 var p = new(Frame_clauseContext) 20187 20188 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 20189 20190 p.parser = parser 20191 p.RuleIndex = ParserRULE_frame_clause 20192 20193 return p 20194 } 20195 20196 func (s *Frame_clauseContext) GetParser() antlr.Parser { return s.parser } 20197 20198 func (s *Frame_clauseContext) RANGE_() antlr.TerminalNode { 20199 return s.GetToken(ParserRANGE_, 0) 20200 } 20201 20202 func (s *Frame_clauseContext) ROWS_() antlr.TerminalNode { 20203 return s.GetToken(ParserROWS_, 0) 20204 } 20205 20206 func (s *Frame_clauseContext) GROUPS_() antlr.TerminalNode { 20207 return s.GetToken(ParserGROUPS_, 0) 20208 } 20209 20210 func (s *Frame_clauseContext) Frame_single() IFrame_singleContext { 20211 var t antlr.RuleContext 20212 for _, ctx := range s.GetChildren() { 20213 if _, ok := ctx.(IFrame_singleContext); ok { 20214 t = ctx.(antlr.RuleContext) 20215 break 20216 } 20217 } 20218 20219 if t == nil { 20220 return nil 20221 } 20222 20223 return t.(IFrame_singleContext) 20224 } 20225 20226 func (s *Frame_clauseContext) BETWEEN_() antlr.TerminalNode { 20227 return s.GetToken(ParserBETWEEN_, 0) 20228 } 20229 20230 func (s *Frame_clauseContext) Frame_left() IFrame_leftContext { 20231 var t antlr.RuleContext 20232 for _, ctx := range s.GetChildren() { 20233 if _, ok := ctx.(IFrame_leftContext); ok { 20234 t = ctx.(antlr.RuleContext) 20235 break 20236 } 20237 } 20238 20239 if t == nil { 20240 return nil 20241 } 20242 20243 return t.(IFrame_leftContext) 20244 } 20245 20246 func (s *Frame_clauseContext) AND_() antlr.TerminalNode { 20247 return s.GetToken(ParserAND_, 0) 20248 } 20249 20250 func (s *Frame_clauseContext) Frame_right() IFrame_rightContext { 20251 var t antlr.RuleContext 20252 for _, ctx := range s.GetChildren() { 20253 if _, ok := ctx.(IFrame_rightContext); ok { 20254 t = ctx.(antlr.RuleContext) 20255 break 20256 } 20257 } 20258 20259 if t == nil { 20260 return nil 20261 } 20262 20263 return t.(IFrame_rightContext) 20264 } 20265 20266 func (s *Frame_clauseContext) GetRuleContext() antlr.RuleContext { 20267 return s 20268 } 20269 20270 func (s *Frame_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 20271 return antlr.TreesStringTree(s, ruleNames, recog) 20272 } 20273 20274 func (s *Frame_clauseContext) EnterRule(listener antlr.ParseTreeListener) { 20275 if listenerT, ok := listener.(ParserListener); ok { 20276 listenerT.EnterFrame_clause(s) 20277 } 20278 } 20279 20280 func (s *Frame_clauseContext) ExitRule(listener antlr.ParseTreeListener) { 20281 if listenerT, ok := listener.(ParserListener); ok { 20282 listenerT.ExitFrame_clause(s) 20283 } 20284 } 20285 20286 func (s *Frame_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 20287 switch t := visitor.(type) { 20288 case ParserVisitor: 20289 return t.VisitFrame_clause(s) 20290 20291 default: 20292 return t.VisitChildren(s) 20293 } 20294 } 20295 20296 func (p *Parser) Frame_clause() (localctx IFrame_clauseContext) { 20297 this := p 20298 _ = this 20299 20300 localctx = NewFrame_clauseContext(p, p.GetParserRuleContext(), p.GetState()) 20301 p.EnterRule(localctx, 126, ParserRULE_frame_clause) 20302 var _la int 20303 20304 defer func() { 20305 p.ExitRule() 20306 }() 20307 20308 defer func() { 20309 if err := recover(); err != nil { 20310 if v, ok := err.(antlr.RecognitionException); ok { 20311 localctx.SetException(v) 20312 p.GetErrorHandler().ReportError(p, v) 20313 p.GetErrorHandler().Recover(p, v) 20314 } else { 20315 panic(err) 20316 } 20317 } 20318 }() 20319 20320 p.EnterOuterAlt(localctx, 1) 20321 { 20322 p.SetState(1745) 20323 _la = p.GetTokenStream().LA(1) 20324 20325 if !(_la == ParserROWS_ || _la == ParserRANGE_ || _la == ParserGROUPS_) { 20326 p.GetErrorHandler().RecoverInline(p) 20327 } else { 20328 p.GetErrorHandler().ReportMatch(p) 20329 p.Consume() 20330 } 20331 } 20332 p.SetState(1752) 20333 p.GetErrorHandler().Sync(p) 20334 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 257, p.GetParserRuleContext()) { 20335 case 1: 20336 { 20337 p.SetState(1746) 20338 p.Frame_single() 20339 } 20340 20341 case 2: 20342 { 20343 p.SetState(1747) 20344 p.Match(ParserBETWEEN_) 20345 } 20346 { 20347 p.SetState(1748) 20348 p.Frame_left() 20349 } 20350 { 20351 p.SetState(1749) 20352 p.Match(ParserAND_) 20353 } 20354 { 20355 p.SetState(1750) 20356 p.Frame_right() 20357 } 20358 20359 } 20360 20361 return localctx 20362 } 20363 20364 // ISimple_function_invocationContext is an interface to support dynamic dispatch. 20365 type ISimple_function_invocationContext interface { 20366 antlr.ParserRuleContext 20367 20368 // GetParser returns the parser. 20369 GetParser() antlr.Parser 20370 20371 // IsSimple_function_invocationContext differentiates from other interfaces. 20372 IsSimple_function_invocationContext() 20373 } 20374 20375 type Simple_function_invocationContext struct { 20376 *antlr.BaseParserRuleContext 20377 parser antlr.Parser 20378 } 20379 20380 func NewEmptySimple_function_invocationContext() *Simple_function_invocationContext { 20381 var p = new(Simple_function_invocationContext) 20382 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 20383 p.RuleIndex = ParserRULE_simple_function_invocation 20384 return p 20385 } 20386 20387 func (*Simple_function_invocationContext) IsSimple_function_invocationContext() {} 20388 20389 func NewSimple_function_invocationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_function_invocationContext { 20390 var p = new(Simple_function_invocationContext) 20391 20392 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 20393 20394 p.parser = parser 20395 p.RuleIndex = ParserRULE_simple_function_invocation 20396 20397 return p 20398 } 20399 20400 func (s *Simple_function_invocationContext) GetParser() antlr.Parser { return s.parser } 20401 20402 func (s *Simple_function_invocationContext) Simple_func() ISimple_funcContext { 20403 var t antlr.RuleContext 20404 for _, ctx := range s.GetChildren() { 20405 if _, ok := ctx.(ISimple_funcContext); ok { 20406 t = ctx.(antlr.RuleContext) 20407 break 20408 } 20409 } 20410 20411 if t == nil { 20412 return nil 20413 } 20414 20415 return t.(ISimple_funcContext) 20416 } 20417 20418 func (s *Simple_function_invocationContext) OPEN_PAR() antlr.TerminalNode { 20419 return s.GetToken(ParserOPEN_PAR, 0) 20420 } 20421 20422 func (s *Simple_function_invocationContext) CLOSE_PAR() antlr.TerminalNode { 20423 return s.GetToken(ParserCLOSE_PAR, 0) 20424 } 20425 20426 func (s *Simple_function_invocationContext) AllExpr() []IExprContext { 20427 children := s.GetChildren() 20428 len := 0 20429 for _, ctx := range children { 20430 if _, ok := ctx.(IExprContext); ok { 20431 len++ 20432 } 20433 } 20434 20435 tst := make([]IExprContext, len) 20436 i := 0 20437 for _, ctx := range children { 20438 if t, ok := ctx.(IExprContext); ok { 20439 tst[i] = t.(IExprContext) 20440 i++ 20441 } 20442 } 20443 20444 return tst 20445 } 20446 20447 func (s *Simple_function_invocationContext) Expr(i int) IExprContext { 20448 var t antlr.RuleContext 20449 j := 0 20450 for _, ctx := range s.GetChildren() { 20451 if _, ok := ctx.(IExprContext); ok { 20452 if j == i { 20453 t = ctx.(antlr.RuleContext) 20454 break 20455 } 20456 j++ 20457 } 20458 } 20459 20460 if t == nil { 20461 return nil 20462 } 20463 20464 return t.(IExprContext) 20465 } 20466 20467 func (s *Simple_function_invocationContext) STAR() antlr.TerminalNode { 20468 return s.GetToken(ParserSTAR, 0) 20469 } 20470 20471 func (s *Simple_function_invocationContext) AllCOMMA() []antlr.TerminalNode { 20472 return s.GetTokens(ParserCOMMA) 20473 } 20474 20475 func (s *Simple_function_invocationContext) COMMA(i int) antlr.TerminalNode { 20476 return s.GetToken(ParserCOMMA, i) 20477 } 20478 20479 func (s *Simple_function_invocationContext) GetRuleContext() antlr.RuleContext { 20480 return s 20481 } 20482 20483 func (s *Simple_function_invocationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 20484 return antlr.TreesStringTree(s, ruleNames, recog) 20485 } 20486 20487 func (s *Simple_function_invocationContext) EnterRule(listener antlr.ParseTreeListener) { 20488 if listenerT, ok := listener.(ParserListener); ok { 20489 listenerT.EnterSimple_function_invocation(s) 20490 } 20491 } 20492 20493 func (s *Simple_function_invocationContext) ExitRule(listener antlr.ParseTreeListener) { 20494 if listenerT, ok := listener.(ParserListener); ok { 20495 listenerT.ExitSimple_function_invocation(s) 20496 } 20497 } 20498 20499 func (s *Simple_function_invocationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 20500 switch t := visitor.(type) { 20501 case ParserVisitor: 20502 return t.VisitSimple_function_invocation(s) 20503 20504 default: 20505 return t.VisitChildren(s) 20506 } 20507 } 20508 20509 func (p *Parser) Simple_function_invocation() (localctx ISimple_function_invocationContext) { 20510 this := p 20511 _ = this 20512 20513 localctx = NewSimple_function_invocationContext(p, p.GetParserRuleContext(), p.GetState()) 20514 p.EnterRule(localctx, 128, ParserRULE_simple_function_invocation) 20515 var _la int 20516 20517 defer func() { 20518 p.ExitRule() 20519 }() 20520 20521 defer func() { 20522 if err := recover(); err != nil { 20523 if v, ok := err.(antlr.RecognitionException); ok { 20524 localctx.SetException(v) 20525 p.GetErrorHandler().ReportError(p, v) 20526 p.GetErrorHandler().Recover(p, v) 20527 } else { 20528 panic(err) 20529 } 20530 } 20531 }() 20532 20533 p.EnterOuterAlt(localctx, 1) 20534 { 20535 p.SetState(1754) 20536 p.Simple_func() 20537 } 20538 { 20539 p.SetState(1755) 20540 p.Match(ParserOPEN_PAR) 20541 } 20542 p.SetState(1765) 20543 p.GetErrorHandler().Sync(p) 20544 20545 switch p.GetTokenStream().LA(1) { 20546 case ParserOPEN_PAR, ParserPLUS, ParserMINUS, ParserTILDE, ParserABORT_, ParserACTION_, ParserADD_, ParserAFTER_, ParserALL_, ParserALTER_, ParserANALYZE_, ParserAND_, ParserAS_, ParserASC_, ParserATTACH_, ParserAUTOINCREMENT_, ParserBEFORE_, ParserBEGIN_, ParserBETWEEN_, ParserBY_, ParserCASCADE_, ParserCASE_, ParserCAST_, ParserCHECK_, ParserCOLLATE_, ParserCOLUMN_, ParserCOMMIT_, ParserCONFLICT_, ParserCONSTRAINT_, ParserCREATE_, ParserCROSS_, ParserCURRENT_DATE_, ParserCURRENT_TIME_, ParserCURRENT_TIMESTAMP_, ParserDATABASE_, ParserDEFAULT_, ParserDEFERRABLE_, ParserDEFERRED_, ParserDELETE_, ParserDESC_, ParserDETACH_, ParserDISTINCT_, ParserDROP_, ParserEACH_, ParserELSE_, ParserEND_, ParserESCAPE_, ParserEXCEPT_, ParserEXCLUSIVE_, ParserEXISTS_, ParserEXPLAIN_, ParserFAIL_, ParserFOR_, ParserFOREIGN_, ParserFROM_, ParserFULL_, ParserGLOB_, ParserGROUP_, ParserHAVING_, ParserIF_, ParserIGNORE_, ParserIMMEDIATE_, ParserIN_, ParserINDEX_, ParserINDEXED_, ParserINITIALLY_, ParserINNER_, ParserINSERT_, ParserINSTEAD_, ParserINTERSECT_, ParserINTO_, ParserIS_, ParserISNULL_, ParserJOIN_, ParserKEY_, ParserLEFT_, ParserLIKE_, ParserLIMIT_, ParserMATCH_, ParserNATURAL_, ParserNO_, ParserNOT_, ParserNOTNULL_, ParserNULL_, ParserOF_, ParserOFFSET_, ParserON_, ParserOR_, ParserORDER_, ParserOUTER_, ParserPLAN_, ParserPRAGMA_, ParserPRIMARY_, ParserQUERY_, ParserRAISE_, ParserRECURSIVE_, ParserREFERENCES_, ParserREGEXP_, ParserREINDEX_, ParserRELEASE_, ParserRENAME_, ParserREPLACE_, ParserRESTRICT_, ParserRIGHT_, ParserROLLBACK_, ParserROW_, ParserROWS_, ParserSAVEPOINT_, ParserSELECT_, ParserSET_, ParserTABLE_, ParserTEMP_, ParserTEMPORARY_, ParserTHEN_, ParserTO_, ParserTRANSACTION_, ParserTRIGGER_, ParserUNION_, ParserUNIQUE_, ParserUPDATE_, ParserUSING_, ParserVACUUM_, ParserVALUES_, ParserVIEW_, ParserVIRTUAL_, ParserWHEN_, ParserWHERE_, ParserWITH_, ParserWITHOUT_, ParserFIRST_VALUE_, ParserOVER_, ParserPARTITION_, ParserRANGE_, ParserPRECEDING_, ParserUNBOUNDED_, ParserCURRENT_, ParserFOLLOWING_, ParserCUME_DIST_, ParserDENSE_RANK_, ParserLAG_, ParserLAST_VALUE_, ParserLEAD_, ParserNTH_VALUE_, ParserNTILE_, ParserPERCENT_RANK_, ParserRANK_, ParserROW_NUMBER_, ParserGENERATED_, ParserALWAYS_, ParserSTORED_, ParserTRUE_, ParserFALSE_, ParserWINDOW_, ParserNULLS_, ParserFIRST_, ParserLAST_, ParserFILTER_, ParserGROUPS_, ParserEXCLUDE_, ParserIDENTIFIER, ParserNUMERIC_LITERAL, ParserBIND_PARAMETER, ParserSTRING_LITERAL, ParserBLOB_LITERAL: 20547 { 20548 p.SetState(1756) 20549 p.expr(0) 20550 } 20551 p.SetState(1761) 20552 p.GetErrorHandler().Sync(p) 20553 _la = p.GetTokenStream().LA(1) 20554 20555 for _la == ParserCOMMA { 20556 { 20557 p.SetState(1757) 20558 p.Match(ParserCOMMA) 20559 } 20560 { 20561 p.SetState(1758) 20562 p.expr(0) 20563 } 20564 20565 p.SetState(1763) 20566 p.GetErrorHandler().Sync(p) 20567 _la = p.GetTokenStream().LA(1) 20568 } 20569 20570 case ParserSTAR: 20571 { 20572 p.SetState(1764) 20573 p.Match(ParserSTAR) 20574 } 20575 20576 default: 20577 panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) 20578 } 20579 { 20580 p.SetState(1767) 20581 p.Match(ParserCLOSE_PAR) 20582 } 20583 20584 return localctx 20585 } 20586 20587 // IAggregate_function_invocationContext is an interface to support dynamic dispatch. 20588 type IAggregate_function_invocationContext interface { 20589 antlr.ParserRuleContext 20590 20591 // GetParser returns the parser. 20592 GetParser() antlr.Parser 20593 20594 // IsAggregate_function_invocationContext differentiates from other interfaces. 20595 IsAggregate_function_invocationContext() 20596 } 20597 20598 type Aggregate_function_invocationContext struct { 20599 *antlr.BaseParserRuleContext 20600 parser antlr.Parser 20601 } 20602 20603 func NewEmptyAggregate_function_invocationContext() *Aggregate_function_invocationContext { 20604 var p = new(Aggregate_function_invocationContext) 20605 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 20606 p.RuleIndex = ParserRULE_aggregate_function_invocation 20607 return p 20608 } 20609 20610 func (*Aggregate_function_invocationContext) IsAggregate_function_invocationContext() {} 20611 20612 func NewAggregate_function_invocationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggregate_function_invocationContext { 20613 var p = new(Aggregate_function_invocationContext) 20614 20615 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 20616 20617 p.parser = parser 20618 p.RuleIndex = ParserRULE_aggregate_function_invocation 20619 20620 return p 20621 } 20622 20623 func (s *Aggregate_function_invocationContext) GetParser() antlr.Parser { return s.parser } 20624 20625 func (s *Aggregate_function_invocationContext) Aggregate_func() IAggregate_funcContext { 20626 var t antlr.RuleContext 20627 for _, ctx := range s.GetChildren() { 20628 if _, ok := ctx.(IAggregate_funcContext); ok { 20629 t = ctx.(antlr.RuleContext) 20630 break 20631 } 20632 } 20633 20634 if t == nil { 20635 return nil 20636 } 20637 20638 return t.(IAggregate_funcContext) 20639 } 20640 20641 func (s *Aggregate_function_invocationContext) OPEN_PAR() antlr.TerminalNode { 20642 return s.GetToken(ParserOPEN_PAR, 0) 20643 } 20644 20645 func (s *Aggregate_function_invocationContext) CLOSE_PAR() antlr.TerminalNode { 20646 return s.GetToken(ParserCLOSE_PAR, 0) 20647 } 20648 20649 func (s *Aggregate_function_invocationContext) AllExpr() []IExprContext { 20650 children := s.GetChildren() 20651 len := 0 20652 for _, ctx := range children { 20653 if _, ok := ctx.(IExprContext); ok { 20654 len++ 20655 } 20656 } 20657 20658 tst := make([]IExprContext, len) 20659 i := 0 20660 for _, ctx := range children { 20661 if t, ok := ctx.(IExprContext); ok { 20662 tst[i] = t.(IExprContext) 20663 i++ 20664 } 20665 } 20666 20667 return tst 20668 } 20669 20670 func (s *Aggregate_function_invocationContext) Expr(i int) IExprContext { 20671 var t antlr.RuleContext 20672 j := 0 20673 for _, ctx := range s.GetChildren() { 20674 if _, ok := ctx.(IExprContext); ok { 20675 if j == i { 20676 t = ctx.(antlr.RuleContext) 20677 break 20678 } 20679 j++ 20680 } 20681 } 20682 20683 if t == nil { 20684 return nil 20685 } 20686 20687 return t.(IExprContext) 20688 } 20689 20690 func (s *Aggregate_function_invocationContext) STAR() antlr.TerminalNode { 20691 return s.GetToken(ParserSTAR, 0) 20692 } 20693 20694 func (s *Aggregate_function_invocationContext) Filter_clause() IFilter_clauseContext { 20695 var t antlr.RuleContext 20696 for _, ctx := range s.GetChildren() { 20697 if _, ok := ctx.(IFilter_clauseContext); ok { 20698 t = ctx.(antlr.RuleContext) 20699 break 20700 } 20701 } 20702 20703 if t == nil { 20704 return nil 20705 } 20706 20707 return t.(IFilter_clauseContext) 20708 } 20709 20710 func (s *Aggregate_function_invocationContext) DISTINCT_() antlr.TerminalNode { 20711 return s.GetToken(ParserDISTINCT_, 0) 20712 } 20713 20714 func (s *Aggregate_function_invocationContext) AllCOMMA() []antlr.TerminalNode { 20715 return s.GetTokens(ParserCOMMA) 20716 } 20717 20718 func (s *Aggregate_function_invocationContext) COMMA(i int) antlr.TerminalNode { 20719 return s.GetToken(ParserCOMMA, i) 20720 } 20721 20722 func (s *Aggregate_function_invocationContext) GetRuleContext() antlr.RuleContext { 20723 return s 20724 } 20725 20726 func (s *Aggregate_function_invocationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 20727 return antlr.TreesStringTree(s, ruleNames, recog) 20728 } 20729 20730 func (s *Aggregate_function_invocationContext) EnterRule(listener antlr.ParseTreeListener) { 20731 if listenerT, ok := listener.(ParserListener); ok { 20732 listenerT.EnterAggregate_function_invocation(s) 20733 } 20734 } 20735 20736 func (s *Aggregate_function_invocationContext) ExitRule(listener antlr.ParseTreeListener) { 20737 if listenerT, ok := listener.(ParserListener); ok { 20738 listenerT.ExitAggregate_function_invocation(s) 20739 } 20740 } 20741 20742 func (s *Aggregate_function_invocationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 20743 switch t := visitor.(type) { 20744 case ParserVisitor: 20745 return t.VisitAggregate_function_invocation(s) 20746 20747 default: 20748 return t.VisitChildren(s) 20749 } 20750 } 20751 20752 func (p *Parser) Aggregate_function_invocation() (localctx IAggregate_function_invocationContext) { 20753 this := p 20754 _ = this 20755 20756 localctx = NewAggregate_function_invocationContext(p, p.GetParserRuleContext(), p.GetState()) 20757 p.EnterRule(localctx, 130, ParserRULE_aggregate_function_invocation) 20758 var _la int 20759 20760 defer func() { 20761 p.ExitRule() 20762 }() 20763 20764 defer func() { 20765 if err := recover(); err != nil { 20766 if v, ok := err.(antlr.RecognitionException); ok { 20767 localctx.SetException(v) 20768 p.GetErrorHandler().ReportError(p, v) 20769 p.GetErrorHandler().Recover(p, v) 20770 } else { 20771 panic(err) 20772 } 20773 } 20774 }() 20775 20776 p.EnterOuterAlt(localctx, 1) 20777 { 20778 p.SetState(1769) 20779 p.Aggregate_func() 20780 } 20781 { 20782 p.SetState(1770) 20783 p.Match(ParserOPEN_PAR) 20784 } 20785 p.SetState(1783) 20786 p.GetErrorHandler().Sync(p) 20787 20788 switch p.GetTokenStream().LA(1) { 20789 case ParserOPEN_PAR, ParserPLUS, ParserMINUS, ParserTILDE, ParserABORT_, ParserACTION_, ParserADD_, ParserAFTER_, ParserALL_, ParserALTER_, ParserANALYZE_, ParserAND_, ParserAS_, ParserASC_, ParserATTACH_, ParserAUTOINCREMENT_, ParserBEFORE_, ParserBEGIN_, ParserBETWEEN_, ParserBY_, ParserCASCADE_, ParserCASE_, ParserCAST_, ParserCHECK_, ParserCOLLATE_, ParserCOLUMN_, ParserCOMMIT_, ParserCONFLICT_, ParserCONSTRAINT_, ParserCREATE_, ParserCROSS_, ParserCURRENT_DATE_, ParserCURRENT_TIME_, ParserCURRENT_TIMESTAMP_, ParserDATABASE_, ParserDEFAULT_, ParserDEFERRABLE_, ParserDEFERRED_, ParserDELETE_, ParserDESC_, ParserDETACH_, ParserDISTINCT_, ParserDROP_, ParserEACH_, ParserELSE_, ParserEND_, ParserESCAPE_, ParserEXCEPT_, ParserEXCLUSIVE_, ParserEXISTS_, ParserEXPLAIN_, ParserFAIL_, ParserFOR_, ParserFOREIGN_, ParserFROM_, ParserFULL_, ParserGLOB_, ParserGROUP_, ParserHAVING_, ParserIF_, ParserIGNORE_, ParserIMMEDIATE_, ParserIN_, ParserINDEX_, ParserINDEXED_, ParserINITIALLY_, ParserINNER_, ParserINSERT_, ParserINSTEAD_, ParserINTERSECT_, ParserINTO_, ParserIS_, ParserISNULL_, ParserJOIN_, ParserKEY_, ParserLEFT_, ParserLIKE_, ParserLIMIT_, ParserMATCH_, ParserNATURAL_, ParserNO_, ParserNOT_, ParserNOTNULL_, ParserNULL_, ParserOF_, ParserOFFSET_, ParserON_, ParserOR_, ParserORDER_, ParserOUTER_, ParserPLAN_, ParserPRAGMA_, ParserPRIMARY_, ParserQUERY_, ParserRAISE_, ParserRECURSIVE_, ParserREFERENCES_, ParserREGEXP_, ParserREINDEX_, ParserRELEASE_, ParserRENAME_, ParserREPLACE_, ParserRESTRICT_, ParserRIGHT_, ParserROLLBACK_, ParserROW_, ParserROWS_, ParserSAVEPOINT_, ParserSELECT_, ParserSET_, ParserTABLE_, ParserTEMP_, ParserTEMPORARY_, ParserTHEN_, ParserTO_, ParserTRANSACTION_, ParserTRIGGER_, ParserUNION_, ParserUNIQUE_, ParserUPDATE_, ParserUSING_, ParserVACUUM_, ParserVALUES_, ParserVIEW_, ParserVIRTUAL_, ParserWHEN_, ParserWHERE_, ParserWITH_, ParserWITHOUT_, ParserFIRST_VALUE_, ParserOVER_, ParserPARTITION_, ParserRANGE_, ParserPRECEDING_, ParserUNBOUNDED_, ParserCURRENT_, ParserFOLLOWING_, ParserCUME_DIST_, ParserDENSE_RANK_, ParserLAG_, ParserLAST_VALUE_, ParserLEAD_, ParserNTH_VALUE_, ParserNTILE_, ParserPERCENT_RANK_, ParserRANK_, ParserROW_NUMBER_, ParserGENERATED_, ParserALWAYS_, ParserSTORED_, ParserTRUE_, ParserFALSE_, ParserWINDOW_, ParserNULLS_, ParserFIRST_, ParserLAST_, ParserFILTER_, ParserGROUPS_, ParserEXCLUDE_, ParserIDENTIFIER, ParserNUMERIC_LITERAL, ParserBIND_PARAMETER, ParserSTRING_LITERAL, ParserBLOB_LITERAL: 20790 p.SetState(1772) 20791 p.GetErrorHandler().Sync(p) 20792 20793 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 260, p.GetParserRuleContext()) == 1 { 20794 { 20795 p.SetState(1771) 20796 p.Match(ParserDISTINCT_) 20797 } 20798 20799 } 20800 { 20801 p.SetState(1774) 20802 p.expr(0) 20803 } 20804 p.SetState(1779) 20805 p.GetErrorHandler().Sync(p) 20806 _la = p.GetTokenStream().LA(1) 20807 20808 for _la == ParserCOMMA { 20809 { 20810 p.SetState(1775) 20811 p.Match(ParserCOMMA) 20812 } 20813 { 20814 p.SetState(1776) 20815 p.expr(0) 20816 } 20817 20818 p.SetState(1781) 20819 p.GetErrorHandler().Sync(p) 20820 _la = p.GetTokenStream().LA(1) 20821 } 20822 20823 case ParserSTAR: 20824 { 20825 p.SetState(1782) 20826 p.Match(ParserSTAR) 20827 } 20828 20829 case ParserCLOSE_PAR: 20830 20831 default: 20832 } 20833 { 20834 p.SetState(1785) 20835 p.Match(ParserCLOSE_PAR) 20836 } 20837 p.SetState(1787) 20838 p.GetErrorHandler().Sync(p) 20839 _la = p.GetTokenStream().LA(1) 20840 20841 if _la == ParserFILTER_ { 20842 { 20843 p.SetState(1786) 20844 p.Filter_clause() 20845 } 20846 20847 } 20848 20849 return localctx 20850 } 20851 20852 // IWindow_function_invocationContext is an interface to support dynamic dispatch. 20853 type IWindow_function_invocationContext interface { 20854 antlr.ParserRuleContext 20855 20856 // GetParser returns the parser. 20857 GetParser() antlr.Parser 20858 20859 // IsWindow_function_invocationContext differentiates from other interfaces. 20860 IsWindow_function_invocationContext() 20861 } 20862 20863 type Window_function_invocationContext struct { 20864 *antlr.BaseParserRuleContext 20865 parser antlr.Parser 20866 } 20867 20868 func NewEmptyWindow_function_invocationContext() *Window_function_invocationContext { 20869 var p = new(Window_function_invocationContext) 20870 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 20871 p.RuleIndex = ParserRULE_window_function_invocation 20872 return p 20873 } 20874 20875 func (*Window_function_invocationContext) IsWindow_function_invocationContext() {} 20876 20877 func NewWindow_function_invocationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_function_invocationContext { 20878 var p = new(Window_function_invocationContext) 20879 20880 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 20881 20882 p.parser = parser 20883 p.RuleIndex = ParserRULE_window_function_invocation 20884 20885 return p 20886 } 20887 20888 func (s *Window_function_invocationContext) GetParser() antlr.Parser { return s.parser } 20889 20890 func (s *Window_function_invocationContext) Window_function() IWindow_functionContext { 20891 var t antlr.RuleContext 20892 for _, ctx := range s.GetChildren() { 20893 if _, ok := ctx.(IWindow_functionContext); ok { 20894 t = ctx.(antlr.RuleContext) 20895 break 20896 } 20897 } 20898 20899 if t == nil { 20900 return nil 20901 } 20902 20903 return t.(IWindow_functionContext) 20904 } 20905 20906 func (s *Window_function_invocationContext) OPEN_PAR() antlr.TerminalNode { 20907 return s.GetToken(ParserOPEN_PAR, 0) 20908 } 20909 20910 func (s *Window_function_invocationContext) CLOSE_PAR() antlr.TerminalNode { 20911 return s.GetToken(ParserCLOSE_PAR, 0) 20912 } 20913 20914 func (s *Window_function_invocationContext) OVER_() antlr.TerminalNode { 20915 return s.GetToken(ParserOVER_, 0) 20916 } 20917 20918 func (s *Window_function_invocationContext) Window_defn() IWindow_defnContext { 20919 var t antlr.RuleContext 20920 for _, ctx := range s.GetChildren() { 20921 if _, ok := ctx.(IWindow_defnContext); ok { 20922 t = ctx.(antlr.RuleContext) 20923 break 20924 } 20925 } 20926 20927 if t == nil { 20928 return nil 20929 } 20930 20931 return t.(IWindow_defnContext) 20932 } 20933 20934 func (s *Window_function_invocationContext) Window_name() IWindow_nameContext { 20935 var t antlr.RuleContext 20936 for _, ctx := range s.GetChildren() { 20937 if _, ok := ctx.(IWindow_nameContext); ok { 20938 t = ctx.(antlr.RuleContext) 20939 break 20940 } 20941 } 20942 20943 if t == nil { 20944 return nil 20945 } 20946 20947 return t.(IWindow_nameContext) 20948 } 20949 20950 func (s *Window_function_invocationContext) AllExpr() []IExprContext { 20951 children := s.GetChildren() 20952 len := 0 20953 for _, ctx := range children { 20954 if _, ok := ctx.(IExprContext); ok { 20955 len++ 20956 } 20957 } 20958 20959 tst := make([]IExprContext, len) 20960 i := 0 20961 for _, ctx := range children { 20962 if t, ok := ctx.(IExprContext); ok { 20963 tst[i] = t.(IExprContext) 20964 i++ 20965 } 20966 } 20967 20968 return tst 20969 } 20970 20971 func (s *Window_function_invocationContext) Expr(i int) IExprContext { 20972 var t antlr.RuleContext 20973 j := 0 20974 for _, ctx := range s.GetChildren() { 20975 if _, ok := ctx.(IExprContext); ok { 20976 if j == i { 20977 t = ctx.(antlr.RuleContext) 20978 break 20979 } 20980 j++ 20981 } 20982 } 20983 20984 if t == nil { 20985 return nil 20986 } 20987 20988 return t.(IExprContext) 20989 } 20990 20991 func (s *Window_function_invocationContext) STAR() antlr.TerminalNode { 20992 return s.GetToken(ParserSTAR, 0) 20993 } 20994 20995 func (s *Window_function_invocationContext) Filter_clause() IFilter_clauseContext { 20996 var t antlr.RuleContext 20997 for _, ctx := range s.GetChildren() { 20998 if _, ok := ctx.(IFilter_clauseContext); ok { 20999 t = ctx.(antlr.RuleContext) 21000 break 21001 } 21002 } 21003 21004 if t == nil { 21005 return nil 21006 } 21007 21008 return t.(IFilter_clauseContext) 21009 } 21010 21011 func (s *Window_function_invocationContext) AllCOMMA() []antlr.TerminalNode { 21012 return s.GetTokens(ParserCOMMA) 21013 } 21014 21015 func (s *Window_function_invocationContext) COMMA(i int) antlr.TerminalNode { 21016 return s.GetToken(ParserCOMMA, i) 21017 } 21018 21019 func (s *Window_function_invocationContext) GetRuleContext() antlr.RuleContext { 21020 return s 21021 } 21022 21023 func (s *Window_function_invocationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 21024 return antlr.TreesStringTree(s, ruleNames, recog) 21025 } 21026 21027 func (s *Window_function_invocationContext) EnterRule(listener antlr.ParseTreeListener) { 21028 if listenerT, ok := listener.(ParserListener); ok { 21029 listenerT.EnterWindow_function_invocation(s) 21030 } 21031 } 21032 21033 func (s *Window_function_invocationContext) ExitRule(listener antlr.ParseTreeListener) { 21034 if listenerT, ok := listener.(ParserListener); ok { 21035 listenerT.ExitWindow_function_invocation(s) 21036 } 21037 } 21038 21039 func (s *Window_function_invocationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 21040 switch t := visitor.(type) { 21041 case ParserVisitor: 21042 return t.VisitWindow_function_invocation(s) 21043 21044 default: 21045 return t.VisitChildren(s) 21046 } 21047 } 21048 21049 func (p *Parser) Window_function_invocation() (localctx IWindow_function_invocationContext) { 21050 this := p 21051 _ = this 21052 21053 localctx = NewWindow_function_invocationContext(p, p.GetParserRuleContext(), p.GetState()) 21054 p.EnterRule(localctx, 132, ParserRULE_window_function_invocation) 21055 var _la int 21056 21057 defer func() { 21058 p.ExitRule() 21059 }() 21060 21061 defer func() { 21062 if err := recover(); err != nil { 21063 if v, ok := err.(antlr.RecognitionException); ok { 21064 localctx.SetException(v) 21065 p.GetErrorHandler().ReportError(p, v) 21066 p.GetErrorHandler().Recover(p, v) 21067 } else { 21068 panic(err) 21069 } 21070 } 21071 }() 21072 21073 p.EnterOuterAlt(localctx, 1) 21074 { 21075 p.SetState(1789) 21076 p.Window_function() 21077 } 21078 { 21079 p.SetState(1790) 21080 p.Match(ParserOPEN_PAR) 21081 } 21082 p.SetState(1800) 21083 p.GetErrorHandler().Sync(p) 21084 21085 switch p.GetTokenStream().LA(1) { 21086 case ParserOPEN_PAR, ParserPLUS, ParserMINUS, ParserTILDE, ParserABORT_, ParserACTION_, ParserADD_, ParserAFTER_, ParserALL_, ParserALTER_, ParserANALYZE_, ParserAND_, ParserAS_, ParserASC_, ParserATTACH_, ParserAUTOINCREMENT_, ParserBEFORE_, ParserBEGIN_, ParserBETWEEN_, ParserBY_, ParserCASCADE_, ParserCASE_, ParserCAST_, ParserCHECK_, ParserCOLLATE_, ParserCOLUMN_, ParserCOMMIT_, ParserCONFLICT_, ParserCONSTRAINT_, ParserCREATE_, ParserCROSS_, ParserCURRENT_DATE_, ParserCURRENT_TIME_, ParserCURRENT_TIMESTAMP_, ParserDATABASE_, ParserDEFAULT_, ParserDEFERRABLE_, ParserDEFERRED_, ParserDELETE_, ParserDESC_, ParserDETACH_, ParserDISTINCT_, ParserDROP_, ParserEACH_, ParserELSE_, ParserEND_, ParserESCAPE_, ParserEXCEPT_, ParserEXCLUSIVE_, ParserEXISTS_, ParserEXPLAIN_, ParserFAIL_, ParserFOR_, ParserFOREIGN_, ParserFROM_, ParserFULL_, ParserGLOB_, ParserGROUP_, ParserHAVING_, ParserIF_, ParserIGNORE_, ParserIMMEDIATE_, ParserIN_, ParserINDEX_, ParserINDEXED_, ParserINITIALLY_, ParserINNER_, ParserINSERT_, ParserINSTEAD_, ParserINTERSECT_, ParserINTO_, ParserIS_, ParserISNULL_, ParserJOIN_, ParserKEY_, ParserLEFT_, ParserLIKE_, ParserLIMIT_, ParserMATCH_, ParserNATURAL_, ParserNO_, ParserNOT_, ParserNOTNULL_, ParserNULL_, ParserOF_, ParserOFFSET_, ParserON_, ParserOR_, ParserORDER_, ParserOUTER_, ParserPLAN_, ParserPRAGMA_, ParserPRIMARY_, ParserQUERY_, ParserRAISE_, ParserRECURSIVE_, ParserREFERENCES_, ParserREGEXP_, ParserREINDEX_, ParserRELEASE_, ParserRENAME_, ParserREPLACE_, ParserRESTRICT_, ParserRIGHT_, ParserROLLBACK_, ParserROW_, ParserROWS_, ParserSAVEPOINT_, ParserSELECT_, ParserSET_, ParserTABLE_, ParserTEMP_, ParserTEMPORARY_, ParserTHEN_, ParserTO_, ParserTRANSACTION_, ParserTRIGGER_, ParserUNION_, ParserUNIQUE_, ParserUPDATE_, ParserUSING_, ParserVACUUM_, ParserVALUES_, ParserVIEW_, ParserVIRTUAL_, ParserWHEN_, ParserWHERE_, ParserWITH_, ParserWITHOUT_, ParserFIRST_VALUE_, ParserOVER_, ParserPARTITION_, ParserRANGE_, ParserPRECEDING_, ParserUNBOUNDED_, ParserCURRENT_, ParserFOLLOWING_, ParserCUME_DIST_, ParserDENSE_RANK_, ParserLAG_, ParserLAST_VALUE_, ParserLEAD_, ParserNTH_VALUE_, ParserNTILE_, ParserPERCENT_RANK_, ParserRANK_, ParserROW_NUMBER_, ParserGENERATED_, ParserALWAYS_, ParserSTORED_, ParserTRUE_, ParserFALSE_, ParserWINDOW_, ParserNULLS_, ParserFIRST_, ParserLAST_, ParserFILTER_, ParserGROUPS_, ParserEXCLUDE_, ParserIDENTIFIER, ParserNUMERIC_LITERAL, ParserBIND_PARAMETER, ParserSTRING_LITERAL, ParserBLOB_LITERAL: 21087 { 21088 p.SetState(1791) 21089 p.expr(0) 21090 } 21091 p.SetState(1796) 21092 p.GetErrorHandler().Sync(p) 21093 _la = p.GetTokenStream().LA(1) 21094 21095 for _la == ParserCOMMA { 21096 { 21097 p.SetState(1792) 21098 p.Match(ParserCOMMA) 21099 } 21100 { 21101 p.SetState(1793) 21102 p.expr(0) 21103 } 21104 21105 p.SetState(1798) 21106 p.GetErrorHandler().Sync(p) 21107 _la = p.GetTokenStream().LA(1) 21108 } 21109 21110 case ParserSTAR: 21111 { 21112 p.SetState(1799) 21113 p.Match(ParserSTAR) 21114 } 21115 21116 case ParserCLOSE_PAR: 21117 21118 default: 21119 } 21120 { 21121 p.SetState(1802) 21122 p.Match(ParserCLOSE_PAR) 21123 } 21124 p.SetState(1804) 21125 p.GetErrorHandler().Sync(p) 21126 _la = p.GetTokenStream().LA(1) 21127 21128 if _la == ParserFILTER_ { 21129 { 21130 p.SetState(1803) 21131 p.Filter_clause() 21132 } 21133 21134 } 21135 { 21136 p.SetState(1806) 21137 p.Match(ParserOVER_) 21138 } 21139 p.SetState(1809) 21140 p.GetErrorHandler().Sync(p) 21141 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 267, p.GetParserRuleContext()) { 21142 case 1: 21143 { 21144 p.SetState(1807) 21145 p.Window_defn() 21146 } 21147 21148 case 2: 21149 { 21150 p.SetState(1808) 21151 p.Window_name() 21152 } 21153 21154 } 21155 21156 return localctx 21157 } 21158 21159 // ICommon_table_stmtContext is an interface to support dynamic dispatch. 21160 type ICommon_table_stmtContext interface { 21161 antlr.ParserRuleContext 21162 21163 // GetParser returns the parser. 21164 GetParser() antlr.Parser 21165 21166 // IsCommon_table_stmtContext differentiates from other interfaces. 21167 IsCommon_table_stmtContext() 21168 } 21169 21170 type Common_table_stmtContext struct { 21171 *antlr.BaseParserRuleContext 21172 parser antlr.Parser 21173 } 21174 21175 func NewEmptyCommon_table_stmtContext() *Common_table_stmtContext { 21176 var p = new(Common_table_stmtContext) 21177 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 21178 p.RuleIndex = ParserRULE_common_table_stmt 21179 return p 21180 } 21181 21182 func (*Common_table_stmtContext) IsCommon_table_stmtContext() {} 21183 21184 func NewCommon_table_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Common_table_stmtContext { 21185 var p = new(Common_table_stmtContext) 21186 21187 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 21188 21189 p.parser = parser 21190 p.RuleIndex = ParserRULE_common_table_stmt 21191 21192 return p 21193 } 21194 21195 func (s *Common_table_stmtContext) GetParser() antlr.Parser { return s.parser } 21196 21197 func (s *Common_table_stmtContext) WITH_() antlr.TerminalNode { 21198 return s.GetToken(ParserWITH_, 0) 21199 } 21200 21201 func (s *Common_table_stmtContext) AllCommon_table_expression() []ICommon_table_expressionContext { 21202 children := s.GetChildren() 21203 len := 0 21204 for _, ctx := range children { 21205 if _, ok := ctx.(ICommon_table_expressionContext); ok { 21206 len++ 21207 } 21208 } 21209 21210 tst := make([]ICommon_table_expressionContext, len) 21211 i := 0 21212 for _, ctx := range children { 21213 if t, ok := ctx.(ICommon_table_expressionContext); ok { 21214 tst[i] = t.(ICommon_table_expressionContext) 21215 i++ 21216 } 21217 } 21218 21219 return tst 21220 } 21221 21222 func (s *Common_table_stmtContext) Common_table_expression(i int) ICommon_table_expressionContext { 21223 var t antlr.RuleContext 21224 j := 0 21225 for _, ctx := range s.GetChildren() { 21226 if _, ok := ctx.(ICommon_table_expressionContext); ok { 21227 if j == i { 21228 t = ctx.(antlr.RuleContext) 21229 break 21230 } 21231 j++ 21232 } 21233 } 21234 21235 if t == nil { 21236 return nil 21237 } 21238 21239 return t.(ICommon_table_expressionContext) 21240 } 21241 21242 func (s *Common_table_stmtContext) RECURSIVE_() antlr.TerminalNode { 21243 return s.GetToken(ParserRECURSIVE_, 0) 21244 } 21245 21246 func (s *Common_table_stmtContext) AllCOMMA() []antlr.TerminalNode { 21247 return s.GetTokens(ParserCOMMA) 21248 } 21249 21250 func (s *Common_table_stmtContext) COMMA(i int) antlr.TerminalNode { 21251 return s.GetToken(ParserCOMMA, i) 21252 } 21253 21254 func (s *Common_table_stmtContext) GetRuleContext() antlr.RuleContext { 21255 return s 21256 } 21257 21258 func (s *Common_table_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 21259 return antlr.TreesStringTree(s, ruleNames, recog) 21260 } 21261 21262 func (s *Common_table_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 21263 if listenerT, ok := listener.(ParserListener); ok { 21264 listenerT.EnterCommon_table_stmt(s) 21265 } 21266 } 21267 21268 func (s *Common_table_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 21269 if listenerT, ok := listener.(ParserListener); ok { 21270 listenerT.ExitCommon_table_stmt(s) 21271 } 21272 } 21273 21274 func (s *Common_table_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 21275 switch t := visitor.(type) { 21276 case ParserVisitor: 21277 return t.VisitCommon_table_stmt(s) 21278 21279 default: 21280 return t.VisitChildren(s) 21281 } 21282 } 21283 21284 func (p *Parser) Common_table_stmt() (localctx ICommon_table_stmtContext) { 21285 this := p 21286 _ = this 21287 21288 localctx = NewCommon_table_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 21289 p.EnterRule(localctx, 134, ParserRULE_common_table_stmt) 21290 var _la int 21291 21292 defer func() { 21293 p.ExitRule() 21294 }() 21295 21296 defer func() { 21297 if err := recover(); err != nil { 21298 if v, ok := err.(antlr.RecognitionException); ok { 21299 localctx.SetException(v) 21300 p.GetErrorHandler().ReportError(p, v) 21301 p.GetErrorHandler().Recover(p, v) 21302 } else { 21303 panic(err) 21304 } 21305 } 21306 }() 21307 21308 p.EnterOuterAlt(localctx, 1) 21309 { 21310 p.SetState(1811) 21311 p.Match(ParserWITH_) 21312 } 21313 p.SetState(1813) 21314 p.GetErrorHandler().Sync(p) 21315 21316 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 268, p.GetParserRuleContext()) == 1 { 21317 { 21318 p.SetState(1812) 21319 p.Match(ParserRECURSIVE_) 21320 } 21321 21322 } 21323 { 21324 p.SetState(1815) 21325 p.Common_table_expression() 21326 } 21327 p.SetState(1820) 21328 p.GetErrorHandler().Sync(p) 21329 _la = p.GetTokenStream().LA(1) 21330 21331 for _la == ParserCOMMA { 21332 { 21333 p.SetState(1816) 21334 p.Match(ParserCOMMA) 21335 } 21336 { 21337 p.SetState(1817) 21338 p.Common_table_expression() 21339 } 21340 21341 p.SetState(1822) 21342 p.GetErrorHandler().Sync(p) 21343 _la = p.GetTokenStream().LA(1) 21344 } 21345 21346 return localctx 21347 } 21348 21349 // IOrder_by_stmtContext is an interface to support dynamic dispatch. 21350 type IOrder_by_stmtContext interface { 21351 antlr.ParserRuleContext 21352 21353 // GetParser returns the parser. 21354 GetParser() antlr.Parser 21355 21356 // IsOrder_by_stmtContext differentiates from other interfaces. 21357 IsOrder_by_stmtContext() 21358 } 21359 21360 type Order_by_stmtContext struct { 21361 *antlr.BaseParserRuleContext 21362 parser antlr.Parser 21363 } 21364 21365 func NewEmptyOrder_by_stmtContext() *Order_by_stmtContext { 21366 var p = new(Order_by_stmtContext) 21367 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 21368 p.RuleIndex = ParserRULE_order_by_stmt 21369 return p 21370 } 21371 21372 func (*Order_by_stmtContext) IsOrder_by_stmtContext() {} 21373 21374 func NewOrder_by_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Order_by_stmtContext { 21375 var p = new(Order_by_stmtContext) 21376 21377 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 21378 21379 p.parser = parser 21380 p.RuleIndex = ParserRULE_order_by_stmt 21381 21382 return p 21383 } 21384 21385 func (s *Order_by_stmtContext) GetParser() antlr.Parser { return s.parser } 21386 21387 func (s *Order_by_stmtContext) ORDER_() antlr.TerminalNode { 21388 return s.GetToken(ParserORDER_, 0) 21389 } 21390 21391 func (s *Order_by_stmtContext) BY_() antlr.TerminalNode { 21392 return s.GetToken(ParserBY_, 0) 21393 } 21394 21395 func (s *Order_by_stmtContext) AllOrdering_term() []IOrdering_termContext { 21396 children := s.GetChildren() 21397 len := 0 21398 for _, ctx := range children { 21399 if _, ok := ctx.(IOrdering_termContext); ok { 21400 len++ 21401 } 21402 } 21403 21404 tst := make([]IOrdering_termContext, len) 21405 i := 0 21406 for _, ctx := range children { 21407 if t, ok := ctx.(IOrdering_termContext); ok { 21408 tst[i] = t.(IOrdering_termContext) 21409 i++ 21410 } 21411 } 21412 21413 return tst 21414 } 21415 21416 func (s *Order_by_stmtContext) Ordering_term(i int) IOrdering_termContext { 21417 var t antlr.RuleContext 21418 j := 0 21419 for _, ctx := range s.GetChildren() { 21420 if _, ok := ctx.(IOrdering_termContext); ok { 21421 if j == i { 21422 t = ctx.(antlr.RuleContext) 21423 break 21424 } 21425 j++ 21426 } 21427 } 21428 21429 if t == nil { 21430 return nil 21431 } 21432 21433 return t.(IOrdering_termContext) 21434 } 21435 21436 func (s *Order_by_stmtContext) AllCOMMA() []antlr.TerminalNode { 21437 return s.GetTokens(ParserCOMMA) 21438 } 21439 21440 func (s *Order_by_stmtContext) COMMA(i int) antlr.TerminalNode { 21441 return s.GetToken(ParserCOMMA, i) 21442 } 21443 21444 func (s *Order_by_stmtContext) GetRuleContext() antlr.RuleContext { 21445 return s 21446 } 21447 21448 func (s *Order_by_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 21449 return antlr.TreesStringTree(s, ruleNames, recog) 21450 } 21451 21452 func (s *Order_by_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 21453 if listenerT, ok := listener.(ParserListener); ok { 21454 listenerT.EnterOrder_by_stmt(s) 21455 } 21456 } 21457 21458 func (s *Order_by_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 21459 if listenerT, ok := listener.(ParserListener); ok { 21460 listenerT.ExitOrder_by_stmt(s) 21461 } 21462 } 21463 21464 func (s *Order_by_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 21465 switch t := visitor.(type) { 21466 case ParserVisitor: 21467 return t.VisitOrder_by_stmt(s) 21468 21469 default: 21470 return t.VisitChildren(s) 21471 } 21472 } 21473 21474 func (p *Parser) Order_by_stmt() (localctx IOrder_by_stmtContext) { 21475 this := p 21476 _ = this 21477 21478 localctx = NewOrder_by_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 21479 p.EnterRule(localctx, 136, ParserRULE_order_by_stmt) 21480 var _la int 21481 21482 defer func() { 21483 p.ExitRule() 21484 }() 21485 21486 defer func() { 21487 if err := recover(); err != nil { 21488 if v, ok := err.(antlr.RecognitionException); ok { 21489 localctx.SetException(v) 21490 p.GetErrorHandler().ReportError(p, v) 21491 p.GetErrorHandler().Recover(p, v) 21492 } else { 21493 panic(err) 21494 } 21495 } 21496 }() 21497 21498 p.EnterOuterAlt(localctx, 1) 21499 { 21500 p.SetState(1823) 21501 p.Match(ParserORDER_) 21502 } 21503 { 21504 p.SetState(1824) 21505 p.Match(ParserBY_) 21506 } 21507 { 21508 p.SetState(1825) 21509 p.Ordering_term() 21510 } 21511 p.SetState(1830) 21512 p.GetErrorHandler().Sync(p) 21513 _la = p.GetTokenStream().LA(1) 21514 21515 for _la == ParserCOMMA { 21516 { 21517 p.SetState(1826) 21518 p.Match(ParserCOMMA) 21519 } 21520 { 21521 p.SetState(1827) 21522 p.Ordering_term() 21523 } 21524 21525 p.SetState(1832) 21526 p.GetErrorHandler().Sync(p) 21527 _la = p.GetTokenStream().LA(1) 21528 } 21529 21530 return localctx 21531 } 21532 21533 // ILimit_stmtContext is an interface to support dynamic dispatch. 21534 type ILimit_stmtContext interface { 21535 antlr.ParserRuleContext 21536 21537 // GetParser returns the parser. 21538 GetParser() antlr.Parser 21539 21540 // IsLimit_stmtContext differentiates from other interfaces. 21541 IsLimit_stmtContext() 21542 } 21543 21544 type Limit_stmtContext struct { 21545 *antlr.BaseParserRuleContext 21546 parser antlr.Parser 21547 } 21548 21549 func NewEmptyLimit_stmtContext() *Limit_stmtContext { 21550 var p = new(Limit_stmtContext) 21551 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 21552 p.RuleIndex = ParserRULE_limit_stmt 21553 return p 21554 } 21555 21556 func (*Limit_stmtContext) IsLimit_stmtContext() {} 21557 21558 func NewLimit_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Limit_stmtContext { 21559 var p = new(Limit_stmtContext) 21560 21561 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 21562 21563 p.parser = parser 21564 p.RuleIndex = ParserRULE_limit_stmt 21565 21566 return p 21567 } 21568 21569 func (s *Limit_stmtContext) GetParser() antlr.Parser { return s.parser } 21570 21571 func (s *Limit_stmtContext) LIMIT_() antlr.TerminalNode { 21572 return s.GetToken(ParserLIMIT_, 0) 21573 } 21574 21575 func (s *Limit_stmtContext) AllExpr() []IExprContext { 21576 children := s.GetChildren() 21577 len := 0 21578 for _, ctx := range children { 21579 if _, ok := ctx.(IExprContext); ok { 21580 len++ 21581 } 21582 } 21583 21584 tst := make([]IExprContext, len) 21585 i := 0 21586 for _, ctx := range children { 21587 if t, ok := ctx.(IExprContext); ok { 21588 tst[i] = t.(IExprContext) 21589 i++ 21590 } 21591 } 21592 21593 return tst 21594 } 21595 21596 func (s *Limit_stmtContext) Expr(i int) IExprContext { 21597 var t antlr.RuleContext 21598 j := 0 21599 for _, ctx := range s.GetChildren() { 21600 if _, ok := ctx.(IExprContext); ok { 21601 if j == i { 21602 t = ctx.(antlr.RuleContext) 21603 break 21604 } 21605 j++ 21606 } 21607 } 21608 21609 if t == nil { 21610 return nil 21611 } 21612 21613 return t.(IExprContext) 21614 } 21615 21616 func (s *Limit_stmtContext) OFFSET_() antlr.TerminalNode { 21617 return s.GetToken(ParserOFFSET_, 0) 21618 } 21619 21620 func (s *Limit_stmtContext) COMMA() antlr.TerminalNode { 21621 return s.GetToken(ParserCOMMA, 0) 21622 } 21623 21624 func (s *Limit_stmtContext) GetRuleContext() antlr.RuleContext { 21625 return s 21626 } 21627 21628 func (s *Limit_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 21629 return antlr.TreesStringTree(s, ruleNames, recog) 21630 } 21631 21632 func (s *Limit_stmtContext) EnterRule(listener antlr.ParseTreeListener) { 21633 if listenerT, ok := listener.(ParserListener); ok { 21634 listenerT.EnterLimit_stmt(s) 21635 } 21636 } 21637 21638 func (s *Limit_stmtContext) ExitRule(listener antlr.ParseTreeListener) { 21639 if listenerT, ok := listener.(ParserListener); ok { 21640 listenerT.ExitLimit_stmt(s) 21641 } 21642 } 21643 21644 func (s *Limit_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 21645 switch t := visitor.(type) { 21646 case ParserVisitor: 21647 return t.VisitLimit_stmt(s) 21648 21649 default: 21650 return t.VisitChildren(s) 21651 } 21652 } 21653 21654 func (p *Parser) Limit_stmt() (localctx ILimit_stmtContext) { 21655 this := p 21656 _ = this 21657 21658 localctx = NewLimit_stmtContext(p, p.GetParserRuleContext(), p.GetState()) 21659 p.EnterRule(localctx, 138, ParserRULE_limit_stmt) 21660 var _la int 21661 21662 defer func() { 21663 p.ExitRule() 21664 }() 21665 21666 defer func() { 21667 if err := recover(); err != nil { 21668 if v, ok := err.(antlr.RecognitionException); ok { 21669 localctx.SetException(v) 21670 p.GetErrorHandler().ReportError(p, v) 21671 p.GetErrorHandler().Recover(p, v) 21672 } else { 21673 panic(err) 21674 } 21675 } 21676 }() 21677 21678 p.EnterOuterAlt(localctx, 1) 21679 { 21680 p.SetState(1833) 21681 p.Match(ParserLIMIT_) 21682 } 21683 { 21684 p.SetState(1834) 21685 p.expr(0) 21686 } 21687 p.SetState(1837) 21688 p.GetErrorHandler().Sync(p) 21689 _la = p.GetTokenStream().LA(1) 21690 21691 if _la == ParserCOMMA || _la == ParserOFFSET_ { 21692 { 21693 p.SetState(1835) 21694 _la = p.GetTokenStream().LA(1) 21695 21696 if !(_la == ParserCOMMA || _la == ParserOFFSET_) { 21697 p.GetErrorHandler().RecoverInline(p) 21698 } else { 21699 p.GetErrorHandler().ReportMatch(p) 21700 p.Consume() 21701 } 21702 } 21703 { 21704 p.SetState(1836) 21705 p.expr(0) 21706 } 21707 21708 } 21709 21710 return localctx 21711 } 21712 21713 // IOrdering_termContext is an interface to support dynamic dispatch. 21714 type IOrdering_termContext interface { 21715 antlr.ParserRuleContext 21716 21717 // GetParser returns the parser. 21718 GetParser() antlr.Parser 21719 21720 // IsOrdering_termContext differentiates from other interfaces. 21721 IsOrdering_termContext() 21722 } 21723 21724 type Ordering_termContext struct { 21725 *antlr.BaseParserRuleContext 21726 parser antlr.Parser 21727 } 21728 21729 func NewEmptyOrdering_termContext() *Ordering_termContext { 21730 var p = new(Ordering_termContext) 21731 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 21732 p.RuleIndex = ParserRULE_ordering_term 21733 return p 21734 } 21735 21736 func (*Ordering_termContext) IsOrdering_termContext() {} 21737 21738 func NewOrdering_termContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ordering_termContext { 21739 var p = new(Ordering_termContext) 21740 21741 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 21742 21743 p.parser = parser 21744 p.RuleIndex = ParserRULE_ordering_term 21745 21746 return p 21747 } 21748 21749 func (s *Ordering_termContext) GetParser() antlr.Parser { return s.parser } 21750 21751 func (s *Ordering_termContext) Expr() IExprContext { 21752 var t antlr.RuleContext 21753 for _, ctx := range s.GetChildren() { 21754 if _, ok := ctx.(IExprContext); ok { 21755 t = ctx.(antlr.RuleContext) 21756 break 21757 } 21758 } 21759 21760 if t == nil { 21761 return nil 21762 } 21763 21764 return t.(IExprContext) 21765 } 21766 21767 func (s *Ordering_termContext) COLLATE_() antlr.TerminalNode { 21768 return s.GetToken(ParserCOLLATE_, 0) 21769 } 21770 21771 func (s *Ordering_termContext) Collation_name() ICollation_nameContext { 21772 var t antlr.RuleContext 21773 for _, ctx := range s.GetChildren() { 21774 if _, ok := ctx.(ICollation_nameContext); ok { 21775 t = ctx.(antlr.RuleContext) 21776 break 21777 } 21778 } 21779 21780 if t == nil { 21781 return nil 21782 } 21783 21784 return t.(ICollation_nameContext) 21785 } 21786 21787 func (s *Ordering_termContext) Asc_desc() IAsc_descContext { 21788 var t antlr.RuleContext 21789 for _, ctx := range s.GetChildren() { 21790 if _, ok := ctx.(IAsc_descContext); ok { 21791 t = ctx.(antlr.RuleContext) 21792 break 21793 } 21794 } 21795 21796 if t == nil { 21797 return nil 21798 } 21799 21800 return t.(IAsc_descContext) 21801 } 21802 21803 func (s *Ordering_termContext) NULLS_() antlr.TerminalNode { 21804 return s.GetToken(ParserNULLS_, 0) 21805 } 21806 21807 func (s *Ordering_termContext) FIRST_() antlr.TerminalNode { 21808 return s.GetToken(ParserFIRST_, 0) 21809 } 21810 21811 func (s *Ordering_termContext) LAST_() antlr.TerminalNode { 21812 return s.GetToken(ParserLAST_, 0) 21813 } 21814 21815 func (s *Ordering_termContext) GetRuleContext() antlr.RuleContext { 21816 return s 21817 } 21818 21819 func (s *Ordering_termContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 21820 return antlr.TreesStringTree(s, ruleNames, recog) 21821 } 21822 21823 func (s *Ordering_termContext) EnterRule(listener antlr.ParseTreeListener) { 21824 if listenerT, ok := listener.(ParserListener); ok { 21825 listenerT.EnterOrdering_term(s) 21826 } 21827 } 21828 21829 func (s *Ordering_termContext) ExitRule(listener antlr.ParseTreeListener) { 21830 if listenerT, ok := listener.(ParserListener); ok { 21831 listenerT.ExitOrdering_term(s) 21832 } 21833 } 21834 21835 func (s *Ordering_termContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 21836 switch t := visitor.(type) { 21837 case ParserVisitor: 21838 return t.VisitOrdering_term(s) 21839 21840 default: 21841 return t.VisitChildren(s) 21842 } 21843 } 21844 21845 func (p *Parser) Ordering_term() (localctx IOrdering_termContext) { 21846 this := p 21847 _ = this 21848 21849 localctx = NewOrdering_termContext(p, p.GetParserRuleContext(), p.GetState()) 21850 p.EnterRule(localctx, 140, ParserRULE_ordering_term) 21851 var _la int 21852 21853 defer func() { 21854 p.ExitRule() 21855 }() 21856 21857 defer func() { 21858 if err := recover(); err != nil { 21859 if v, ok := err.(antlr.RecognitionException); ok { 21860 localctx.SetException(v) 21861 p.GetErrorHandler().ReportError(p, v) 21862 p.GetErrorHandler().Recover(p, v) 21863 } else { 21864 panic(err) 21865 } 21866 } 21867 }() 21868 21869 p.EnterOuterAlt(localctx, 1) 21870 { 21871 p.SetState(1839) 21872 p.expr(0) 21873 } 21874 p.SetState(1842) 21875 p.GetErrorHandler().Sync(p) 21876 _la = p.GetTokenStream().LA(1) 21877 21878 if _la == ParserCOLLATE_ { 21879 { 21880 p.SetState(1840) 21881 p.Match(ParserCOLLATE_) 21882 } 21883 { 21884 p.SetState(1841) 21885 p.Collation_name() 21886 } 21887 21888 } 21889 p.SetState(1845) 21890 p.GetErrorHandler().Sync(p) 21891 _la = p.GetTokenStream().LA(1) 21892 21893 if _la == ParserASC_ || _la == ParserDESC_ { 21894 { 21895 p.SetState(1844) 21896 p.Asc_desc() 21897 } 21898 21899 } 21900 p.SetState(1849) 21901 p.GetErrorHandler().Sync(p) 21902 _la = p.GetTokenStream().LA(1) 21903 21904 if _la == ParserNULLS_ { 21905 { 21906 p.SetState(1847) 21907 p.Match(ParserNULLS_) 21908 } 21909 { 21910 p.SetState(1848) 21911 _la = p.GetTokenStream().LA(1) 21912 21913 if !(_la == ParserFIRST_ || _la == ParserLAST_) { 21914 p.GetErrorHandler().RecoverInline(p) 21915 } else { 21916 p.GetErrorHandler().ReportMatch(p) 21917 p.Consume() 21918 } 21919 } 21920 21921 } 21922 21923 return localctx 21924 } 21925 21926 // IAsc_descContext is an interface to support dynamic dispatch. 21927 type IAsc_descContext interface { 21928 antlr.ParserRuleContext 21929 21930 // GetParser returns the parser. 21931 GetParser() antlr.Parser 21932 21933 // IsAsc_descContext differentiates from other interfaces. 21934 IsAsc_descContext() 21935 } 21936 21937 type Asc_descContext struct { 21938 *antlr.BaseParserRuleContext 21939 parser antlr.Parser 21940 } 21941 21942 func NewEmptyAsc_descContext() *Asc_descContext { 21943 var p = new(Asc_descContext) 21944 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 21945 p.RuleIndex = ParserRULE_asc_desc 21946 return p 21947 } 21948 21949 func (*Asc_descContext) IsAsc_descContext() {} 21950 21951 func NewAsc_descContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Asc_descContext { 21952 var p = new(Asc_descContext) 21953 21954 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 21955 21956 p.parser = parser 21957 p.RuleIndex = ParserRULE_asc_desc 21958 21959 return p 21960 } 21961 21962 func (s *Asc_descContext) GetParser() antlr.Parser { return s.parser } 21963 21964 func (s *Asc_descContext) ASC_() antlr.TerminalNode { 21965 return s.GetToken(ParserASC_, 0) 21966 } 21967 21968 func (s *Asc_descContext) DESC_() antlr.TerminalNode { 21969 return s.GetToken(ParserDESC_, 0) 21970 } 21971 21972 func (s *Asc_descContext) GetRuleContext() antlr.RuleContext { 21973 return s 21974 } 21975 21976 func (s *Asc_descContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 21977 return antlr.TreesStringTree(s, ruleNames, recog) 21978 } 21979 21980 func (s *Asc_descContext) EnterRule(listener antlr.ParseTreeListener) { 21981 if listenerT, ok := listener.(ParserListener); ok { 21982 listenerT.EnterAsc_desc(s) 21983 } 21984 } 21985 21986 func (s *Asc_descContext) ExitRule(listener antlr.ParseTreeListener) { 21987 if listenerT, ok := listener.(ParserListener); ok { 21988 listenerT.ExitAsc_desc(s) 21989 } 21990 } 21991 21992 func (s *Asc_descContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 21993 switch t := visitor.(type) { 21994 case ParserVisitor: 21995 return t.VisitAsc_desc(s) 21996 21997 default: 21998 return t.VisitChildren(s) 21999 } 22000 } 22001 22002 func (p *Parser) Asc_desc() (localctx IAsc_descContext) { 22003 this := p 22004 _ = this 22005 22006 localctx = NewAsc_descContext(p, p.GetParserRuleContext(), p.GetState()) 22007 p.EnterRule(localctx, 142, ParserRULE_asc_desc) 22008 var _la int 22009 22010 defer func() { 22011 p.ExitRule() 22012 }() 22013 22014 defer func() { 22015 if err := recover(); err != nil { 22016 if v, ok := err.(antlr.RecognitionException); ok { 22017 localctx.SetException(v) 22018 p.GetErrorHandler().ReportError(p, v) 22019 p.GetErrorHandler().Recover(p, v) 22020 } else { 22021 panic(err) 22022 } 22023 } 22024 }() 22025 22026 p.EnterOuterAlt(localctx, 1) 22027 { 22028 p.SetState(1851) 22029 _la = p.GetTokenStream().LA(1) 22030 22031 if !(_la == ParserASC_ || _la == ParserDESC_) { 22032 p.GetErrorHandler().RecoverInline(p) 22033 } else { 22034 p.GetErrorHandler().ReportMatch(p) 22035 p.Consume() 22036 } 22037 } 22038 22039 return localctx 22040 } 22041 22042 // IFrame_leftContext is an interface to support dynamic dispatch. 22043 type IFrame_leftContext interface { 22044 antlr.ParserRuleContext 22045 22046 // GetParser returns the parser. 22047 GetParser() antlr.Parser 22048 22049 // IsFrame_leftContext differentiates from other interfaces. 22050 IsFrame_leftContext() 22051 } 22052 22053 type Frame_leftContext struct { 22054 *antlr.BaseParserRuleContext 22055 parser antlr.Parser 22056 } 22057 22058 func NewEmptyFrame_leftContext() *Frame_leftContext { 22059 var p = new(Frame_leftContext) 22060 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 22061 p.RuleIndex = ParserRULE_frame_left 22062 return p 22063 } 22064 22065 func (*Frame_leftContext) IsFrame_leftContext() {} 22066 22067 func NewFrame_leftContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Frame_leftContext { 22068 var p = new(Frame_leftContext) 22069 22070 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 22071 22072 p.parser = parser 22073 p.RuleIndex = ParserRULE_frame_left 22074 22075 return p 22076 } 22077 22078 func (s *Frame_leftContext) GetParser() antlr.Parser { return s.parser } 22079 22080 func (s *Frame_leftContext) Expr() IExprContext { 22081 var t antlr.RuleContext 22082 for _, ctx := range s.GetChildren() { 22083 if _, ok := ctx.(IExprContext); ok { 22084 t = ctx.(antlr.RuleContext) 22085 break 22086 } 22087 } 22088 22089 if t == nil { 22090 return nil 22091 } 22092 22093 return t.(IExprContext) 22094 } 22095 22096 func (s *Frame_leftContext) PRECEDING_() antlr.TerminalNode { 22097 return s.GetToken(ParserPRECEDING_, 0) 22098 } 22099 22100 func (s *Frame_leftContext) FOLLOWING_() antlr.TerminalNode { 22101 return s.GetToken(ParserFOLLOWING_, 0) 22102 } 22103 22104 func (s *Frame_leftContext) CURRENT_() antlr.TerminalNode { 22105 return s.GetToken(ParserCURRENT_, 0) 22106 } 22107 22108 func (s *Frame_leftContext) ROW_() antlr.TerminalNode { 22109 return s.GetToken(ParserROW_, 0) 22110 } 22111 22112 func (s *Frame_leftContext) UNBOUNDED_() antlr.TerminalNode { 22113 return s.GetToken(ParserUNBOUNDED_, 0) 22114 } 22115 22116 func (s *Frame_leftContext) GetRuleContext() antlr.RuleContext { 22117 return s 22118 } 22119 22120 func (s *Frame_leftContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 22121 return antlr.TreesStringTree(s, ruleNames, recog) 22122 } 22123 22124 func (s *Frame_leftContext) EnterRule(listener antlr.ParseTreeListener) { 22125 if listenerT, ok := listener.(ParserListener); ok { 22126 listenerT.EnterFrame_left(s) 22127 } 22128 } 22129 22130 func (s *Frame_leftContext) ExitRule(listener antlr.ParseTreeListener) { 22131 if listenerT, ok := listener.(ParserListener); ok { 22132 listenerT.ExitFrame_left(s) 22133 } 22134 } 22135 22136 func (s *Frame_leftContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 22137 switch t := visitor.(type) { 22138 case ParserVisitor: 22139 return t.VisitFrame_left(s) 22140 22141 default: 22142 return t.VisitChildren(s) 22143 } 22144 } 22145 22146 func (p *Parser) Frame_left() (localctx IFrame_leftContext) { 22147 this := p 22148 _ = this 22149 22150 localctx = NewFrame_leftContext(p, p.GetParserRuleContext(), p.GetState()) 22151 p.EnterRule(localctx, 144, ParserRULE_frame_left) 22152 22153 defer func() { 22154 p.ExitRule() 22155 }() 22156 22157 defer func() { 22158 if err := recover(); err != nil { 22159 if v, ok := err.(antlr.RecognitionException); ok { 22160 localctx.SetException(v) 22161 p.GetErrorHandler().ReportError(p, v) 22162 p.GetErrorHandler().Recover(p, v) 22163 } else { 22164 panic(err) 22165 } 22166 } 22167 }() 22168 22169 p.SetState(1863) 22170 p.GetErrorHandler().Sync(p) 22171 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 275, p.GetParserRuleContext()) { 22172 case 1: 22173 p.EnterOuterAlt(localctx, 1) 22174 { 22175 p.SetState(1853) 22176 p.expr(0) 22177 } 22178 { 22179 p.SetState(1854) 22180 p.Match(ParserPRECEDING_) 22181 } 22182 22183 case 2: 22184 p.EnterOuterAlt(localctx, 2) 22185 { 22186 p.SetState(1856) 22187 p.expr(0) 22188 } 22189 { 22190 p.SetState(1857) 22191 p.Match(ParserFOLLOWING_) 22192 } 22193 22194 case 3: 22195 p.EnterOuterAlt(localctx, 3) 22196 { 22197 p.SetState(1859) 22198 p.Match(ParserCURRENT_) 22199 } 22200 { 22201 p.SetState(1860) 22202 p.Match(ParserROW_) 22203 } 22204 22205 case 4: 22206 p.EnterOuterAlt(localctx, 4) 22207 { 22208 p.SetState(1861) 22209 p.Match(ParserUNBOUNDED_) 22210 } 22211 { 22212 p.SetState(1862) 22213 p.Match(ParserPRECEDING_) 22214 } 22215 22216 } 22217 22218 return localctx 22219 } 22220 22221 // IFrame_rightContext is an interface to support dynamic dispatch. 22222 type IFrame_rightContext interface { 22223 antlr.ParserRuleContext 22224 22225 // GetParser returns the parser. 22226 GetParser() antlr.Parser 22227 22228 // IsFrame_rightContext differentiates from other interfaces. 22229 IsFrame_rightContext() 22230 } 22231 22232 type Frame_rightContext struct { 22233 *antlr.BaseParserRuleContext 22234 parser antlr.Parser 22235 } 22236 22237 func NewEmptyFrame_rightContext() *Frame_rightContext { 22238 var p = new(Frame_rightContext) 22239 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 22240 p.RuleIndex = ParserRULE_frame_right 22241 return p 22242 } 22243 22244 func (*Frame_rightContext) IsFrame_rightContext() {} 22245 22246 func NewFrame_rightContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Frame_rightContext { 22247 var p = new(Frame_rightContext) 22248 22249 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 22250 22251 p.parser = parser 22252 p.RuleIndex = ParserRULE_frame_right 22253 22254 return p 22255 } 22256 22257 func (s *Frame_rightContext) GetParser() antlr.Parser { return s.parser } 22258 22259 func (s *Frame_rightContext) Expr() IExprContext { 22260 var t antlr.RuleContext 22261 for _, ctx := range s.GetChildren() { 22262 if _, ok := ctx.(IExprContext); ok { 22263 t = ctx.(antlr.RuleContext) 22264 break 22265 } 22266 } 22267 22268 if t == nil { 22269 return nil 22270 } 22271 22272 return t.(IExprContext) 22273 } 22274 22275 func (s *Frame_rightContext) PRECEDING_() antlr.TerminalNode { 22276 return s.GetToken(ParserPRECEDING_, 0) 22277 } 22278 22279 func (s *Frame_rightContext) FOLLOWING_() antlr.TerminalNode { 22280 return s.GetToken(ParserFOLLOWING_, 0) 22281 } 22282 22283 func (s *Frame_rightContext) CURRENT_() antlr.TerminalNode { 22284 return s.GetToken(ParserCURRENT_, 0) 22285 } 22286 22287 func (s *Frame_rightContext) ROW_() antlr.TerminalNode { 22288 return s.GetToken(ParserROW_, 0) 22289 } 22290 22291 func (s *Frame_rightContext) UNBOUNDED_() antlr.TerminalNode { 22292 return s.GetToken(ParserUNBOUNDED_, 0) 22293 } 22294 22295 func (s *Frame_rightContext) GetRuleContext() antlr.RuleContext { 22296 return s 22297 } 22298 22299 func (s *Frame_rightContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 22300 return antlr.TreesStringTree(s, ruleNames, recog) 22301 } 22302 22303 func (s *Frame_rightContext) EnterRule(listener antlr.ParseTreeListener) { 22304 if listenerT, ok := listener.(ParserListener); ok { 22305 listenerT.EnterFrame_right(s) 22306 } 22307 } 22308 22309 func (s *Frame_rightContext) ExitRule(listener antlr.ParseTreeListener) { 22310 if listenerT, ok := listener.(ParserListener); ok { 22311 listenerT.ExitFrame_right(s) 22312 } 22313 } 22314 22315 func (s *Frame_rightContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 22316 switch t := visitor.(type) { 22317 case ParserVisitor: 22318 return t.VisitFrame_right(s) 22319 22320 default: 22321 return t.VisitChildren(s) 22322 } 22323 } 22324 22325 func (p *Parser) Frame_right() (localctx IFrame_rightContext) { 22326 this := p 22327 _ = this 22328 22329 localctx = NewFrame_rightContext(p, p.GetParserRuleContext(), p.GetState()) 22330 p.EnterRule(localctx, 146, ParserRULE_frame_right) 22331 22332 defer func() { 22333 p.ExitRule() 22334 }() 22335 22336 defer func() { 22337 if err := recover(); err != nil { 22338 if v, ok := err.(antlr.RecognitionException); ok { 22339 localctx.SetException(v) 22340 p.GetErrorHandler().ReportError(p, v) 22341 p.GetErrorHandler().Recover(p, v) 22342 } else { 22343 panic(err) 22344 } 22345 } 22346 }() 22347 22348 p.SetState(1875) 22349 p.GetErrorHandler().Sync(p) 22350 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 276, p.GetParserRuleContext()) { 22351 case 1: 22352 p.EnterOuterAlt(localctx, 1) 22353 { 22354 p.SetState(1865) 22355 p.expr(0) 22356 } 22357 { 22358 p.SetState(1866) 22359 p.Match(ParserPRECEDING_) 22360 } 22361 22362 case 2: 22363 p.EnterOuterAlt(localctx, 2) 22364 { 22365 p.SetState(1868) 22366 p.expr(0) 22367 } 22368 { 22369 p.SetState(1869) 22370 p.Match(ParserFOLLOWING_) 22371 } 22372 22373 case 3: 22374 p.EnterOuterAlt(localctx, 3) 22375 { 22376 p.SetState(1871) 22377 p.Match(ParserCURRENT_) 22378 } 22379 { 22380 p.SetState(1872) 22381 p.Match(ParserROW_) 22382 } 22383 22384 case 4: 22385 p.EnterOuterAlt(localctx, 4) 22386 { 22387 p.SetState(1873) 22388 p.Match(ParserUNBOUNDED_) 22389 } 22390 { 22391 p.SetState(1874) 22392 p.Match(ParserFOLLOWING_) 22393 } 22394 22395 } 22396 22397 return localctx 22398 } 22399 22400 // IFrame_singleContext is an interface to support dynamic dispatch. 22401 type IFrame_singleContext interface { 22402 antlr.ParserRuleContext 22403 22404 // GetParser returns the parser. 22405 GetParser() antlr.Parser 22406 22407 // IsFrame_singleContext differentiates from other interfaces. 22408 IsFrame_singleContext() 22409 } 22410 22411 type Frame_singleContext struct { 22412 *antlr.BaseParserRuleContext 22413 parser antlr.Parser 22414 } 22415 22416 func NewEmptyFrame_singleContext() *Frame_singleContext { 22417 var p = new(Frame_singleContext) 22418 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 22419 p.RuleIndex = ParserRULE_frame_single 22420 return p 22421 } 22422 22423 func (*Frame_singleContext) IsFrame_singleContext() {} 22424 22425 func NewFrame_singleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Frame_singleContext { 22426 var p = new(Frame_singleContext) 22427 22428 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 22429 22430 p.parser = parser 22431 p.RuleIndex = ParserRULE_frame_single 22432 22433 return p 22434 } 22435 22436 func (s *Frame_singleContext) GetParser() antlr.Parser { return s.parser } 22437 22438 func (s *Frame_singleContext) Expr() IExprContext { 22439 var t antlr.RuleContext 22440 for _, ctx := range s.GetChildren() { 22441 if _, ok := ctx.(IExprContext); ok { 22442 t = ctx.(antlr.RuleContext) 22443 break 22444 } 22445 } 22446 22447 if t == nil { 22448 return nil 22449 } 22450 22451 return t.(IExprContext) 22452 } 22453 22454 func (s *Frame_singleContext) PRECEDING_() antlr.TerminalNode { 22455 return s.GetToken(ParserPRECEDING_, 0) 22456 } 22457 22458 func (s *Frame_singleContext) UNBOUNDED_() antlr.TerminalNode { 22459 return s.GetToken(ParserUNBOUNDED_, 0) 22460 } 22461 22462 func (s *Frame_singleContext) CURRENT_() antlr.TerminalNode { 22463 return s.GetToken(ParserCURRENT_, 0) 22464 } 22465 22466 func (s *Frame_singleContext) ROW_() antlr.TerminalNode { 22467 return s.GetToken(ParserROW_, 0) 22468 } 22469 22470 func (s *Frame_singleContext) GetRuleContext() antlr.RuleContext { 22471 return s 22472 } 22473 22474 func (s *Frame_singleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 22475 return antlr.TreesStringTree(s, ruleNames, recog) 22476 } 22477 22478 func (s *Frame_singleContext) EnterRule(listener antlr.ParseTreeListener) { 22479 if listenerT, ok := listener.(ParserListener); ok { 22480 listenerT.EnterFrame_single(s) 22481 } 22482 } 22483 22484 func (s *Frame_singleContext) ExitRule(listener antlr.ParseTreeListener) { 22485 if listenerT, ok := listener.(ParserListener); ok { 22486 listenerT.ExitFrame_single(s) 22487 } 22488 } 22489 22490 func (s *Frame_singleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 22491 switch t := visitor.(type) { 22492 case ParserVisitor: 22493 return t.VisitFrame_single(s) 22494 22495 default: 22496 return t.VisitChildren(s) 22497 } 22498 } 22499 22500 func (p *Parser) Frame_single() (localctx IFrame_singleContext) { 22501 this := p 22502 _ = this 22503 22504 localctx = NewFrame_singleContext(p, p.GetParserRuleContext(), p.GetState()) 22505 p.EnterRule(localctx, 148, ParserRULE_frame_single) 22506 22507 defer func() { 22508 p.ExitRule() 22509 }() 22510 22511 defer func() { 22512 if err := recover(); err != nil { 22513 if v, ok := err.(antlr.RecognitionException); ok { 22514 localctx.SetException(v) 22515 p.GetErrorHandler().ReportError(p, v) 22516 p.GetErrorHandler().Recover(p, v) 22517 } else { 22518 panic(err) 22519 } 22520 } 22521 }() 22522 22523 p.SetState(1884) 22524 p.GetErrorHandler().Sync(p) 22525 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 277, p.GetParserRuleContext()) { 22526 case 1: 22527 p.EnterOuterAlt(localctx, 1) 22528 { 22529 p.SetState(1877) 22530 p.expr(0) 22531 } 22532 { 22533 p.SetState(1878) 22534 p.Match(ParserPRECEDING_) 22535 } 22536 22537 case 2: 22538 p.EnterOuterAlt(localctx, 2) 22539 { 22540 p.SetState(1880) 22541 p.Match(ParserUNBOUNDED_) 22542 } 22543 { 22544 p.SetState(1881) 22545 p.Match(ParserPRECEDING_) 22546 } 22547 22548 case 3: 22549 p.EnterOuterAlt(localctx, 3) 22550 { 22551 p.SetState(1882) 22552 p.Match(ParserCURRENT_) 22553 } 22554 { 22555 p.SetState(1883) 22556 p.Match(ParserROW_) 22557 } 22558 22559 } 22560 22561 return localctx 22562 } 22563 22564 // IWindow_functionContext is an interface to support dynamic dispatch. 22565 type IWindow_functionContext interface { 22566 antlr.ParserRuleContext 22567 22568 // GetParser returns the parser. 22569 GetParser() antlr.Parser 22570 22571 // IsWindow_functionContext differentiates from other interfaces. 22572 IsWindow_functionContext() 22573 } 22574 22575 type Window_functionContext struct { 22576 *antlr.BaseParserRuleContext 22577 parser antlr.Parser 22578 } 22579 22580 func NewEmptyWindow_functionContext() *Window_functionContext { 22581 var p = new(Window_functionContext) 22582 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 22583 p.RuleIndex = ParserRULE_window_function 22584 return p 22585 } 22586 22587 func (*Window_functionContext) IsWindow_functionContext() {} 22588 22589 func NewWindow_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_functionContext { 22590 var p = new(Window_functionContext) 22591 22592 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 22593 22594 p.parser = parser 22595 p.RuleIndex = ParserRULE_window_function 22596 22597 return p 22598 } 22599 22600 func (s *Window_functionContext) GetParser() antlr.Parser { return s.parser } 22601 22602 func (s *Window_functionContext) AllOPEN_PAR() []antlr.TerminalNode { 22603 return s.GetTokens(ParserOPEN_PAR) 22604 } 22605 22606 func (s *Window_functionContext) OPEN_PAR(i int) antlr.TerminalNode { 22607 return s.GetToken(ParserOPEN_PAR, i) 22608 } 22609 22610 func (s *Window_functionContext) Expr() IExprContext { 22611 var t antlr.RuleContext 22612 for _, ctx := range s.GetChildren() { 22613 if _, ok := ctx.(IExprContext); ok { 22614 t = ctx.(antlr.RuleContext) 22615 break 22616 } 22617 } 22618 22619 if t == nil { 22620 return nil 22621 } 22622 22623 return t.(IExprContext) 22624 } 22625 22626 func (s *Window_functionContext) AllCLOSE_PAR() []antlr.TerminalNode { 22627 return s.GetTokens(ParserCLOSE_PAR) 22628 } 22629 22630 func (s *Window_functionContext) CLOSE_PAR(i int) antlr.TerminalNode { 22631 return s.GetToken(ParserCLOSE_PAR, i) 22632 } 22633 22634 func (s *Window_functionContext) OVER_() antlr.TerminalNode { 22635 return s.GetToken(ParserOVER_, 0) 22636 } 22637 22638 func (s *Window_functionContext) Order_by_expr_asc_desc() IOrder_by_expr_asc_descContext { 22639 var t antlr.RuleContext 22640 for _, ctx := range s.GetChildren() { 22641 if _, ok := ctx.(IOrder_by_expr_asc_descContext); ok { 22642 t = ctx.(antlr.RuleContext) 22643 break 22644 } 22645 } 22646 22647 if t == nil { 22648 return nil 22649 } 22650 22651 return t.(IOrder_by_expr_asc_descContext) 22652 } 22653 22654 func (s *Window_functionContext) FIRST_VALUE_() antlr.TerminalNode { 22655 return s.GetToken(ParserFIRST_VALUE_, 0) 22656 } 22657 22658 func (s *Window_functionContext) LAST_VALUE_() antlr.TerminalNode { 22659 return s.GetToken(ParserLAST_VALUE_, 0) 22660 } 22661 22662 func (s *Window_functionContext) Partition_by() IPartition_byContext { 22663 var t antlr.RuleContext 22664 for _, ctx := range s.GetChildren() { 22665 if _, ok := ctx.(IPartition_byContext); ok { 22666 t = ctx.(antlr.RuleContext) 22667 break 22668 } 22669 } 22670 22671 if t == nil { 22672 return nil 22673 } 22674 22675 return t.(IPartition_byContext) 22676 } 22677 22678 func (s *Window_functionContext) Frame_clause() IFrame_clauseContext { 22679 var t antlr.RuleContext 22680 for _, ctx := range s.GetChildren() { 22681 if _, ok := ctx.(IFrame_clauseContext); ok { 22682 t = ctx.(antlr.RuleContext) 22683 break 22684 } 22685 } 22686 22687 if t == nil { 22688 return nil 22689 } 22690 22691 return t.(IFrame_clauseContext) 22692 } 22693 22694 func (s *Window_functionContext) CUME_DIST_() antlr.TerminalNode { 22695 return s.GetToken(ParserCUME_DIST_, 0) 22696 } 22697 22698 func (s *Window_functionContext) PERCENT_RANK_() antlr.TerminalNode { 22699 return s.GetToken(ParserPERCENT_RANK_, 0) 22700 } 22701 22702 func (s *Window_functionContext) Order_by_expr() IOrder_by_exprContext { 22703 var t antlr.RuleContext 22704 for _, ctx := range s.GetChildren() { 22705 if _, ok := ctx.(IOrder_by_exprContext); ok { 22706 t = ctx.(antlr.RuleContext) 22707 break 22708 } 22709 } 22710 22711 if t == nil { 22712 return nil 22713 } 22714 22715 return t.(IOrder_by_exprContext) 22716 } 22717 22718 func (s *Window_functionContext) DENSE_RANK_() antlr.TerminalNode { 22719 return s.GetToken(ParserDENSE_RANK_, 0) 22720 } 22721 22722 func (s *Window_functionContext) RANK_() antlr.TerminalNode { 22723 return s.GetToken(ParserRANK_, 0) 22724 } 22725 22726 func (s *Window_functionContext) ROW_NUMBER_() antlr.TerminalNode { 22727 return s.GetToken(ParserROW_NUMBER_, 0) 22728 } 22729 22730 func (s *Window_functionContext) LAG_() antlr.TerminalNode { 22731 return s.GetToken(ParserLAG_, 0) 22732 } 22733 22734 func (s *Window_functionContext) LEAD_() antlr.TerminalNode { 22735 return s.GetToken(ParserLEAD_, 0) 22736 } 22737 22738 func (s *Window_functionContext) Offset() IOffsetContext { 22739 var t antlr.RuleContext 22740 for _, ctx := range s.GetChildren() { 22741 if _, ok := ctx.(IOffsetContext); ok { 22742 t = ctx.(antlr.RuleContext) 22743 break 22744 } 22745 } 22746 22747 if t == nil { 22748 return nil 22749 } 22750 22751 return t.(IOffsetContext) 22752 } 22753 22754 func (s *Window_functionContext) Default_value() IDefault_valueContext { 22755 var t antlr.RuleContext 22756 for _, ctx := range s.GetChildren() { 22757 if _, ok := ctx.(IDefault_valueContext); ok { 22758 t = ctx.(antlr.RuleContext) 22759 break 22760 } 22761 } 22762 22763 if t == nil { 22764 return nil 22765 } 22766 22767 return t.(IDefault_valueContext) 22768 } 22769 22770 func (s *Window_functionContext) NTH_VALUE_() antlr.TerminalNode { 22771 return s.GetToken(ParserNTH_VALUE_, 0) 22772 } 22773 22774 func (s *Window_functionContext) COMMA() antlr.TerminalNode { 22775 return s.GetToken(ParserCOMMA, 0) 22776 } 22777 22778 func (s *Window_functionContext) Signed_number() ISigned_numberContext { 22779 var t antlr.RuleContext 22780 for _, ctx := range s.GetChildren() { 22781 if _, ok := ctx.(ISigned_numberContext); ok { 22782 t = ctx.(antlr.RuleContext) 22783 break 22784 } 22785 } 22786 22787 if t == nil { 22788 return nil 22789 } 22790 22791 return t.(ISigned_numberContext) 22792 } 22793 22794 func (s *Window_functionContext) NTILE_() antlr.TerminalNode { 22795 return s.GetToken(ParserNTILE_, 0) 22796 } 22797 22798 func (s *Window_functionContext) GetRuleContext() antlr.RuleContext { 22799 return s 22800 } 22801 22802 func (s *Window_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 22803 return antlr.TreesStringTree(s, ruleNames, recog) 22804 } 22805 22806 func (s *Window_functionContext) EnterRule(listener antlr.ParseTreeListener) { 22807 if listenerT, ok := listener.(ParserListener); ok { 22808 listenerT.EnterWindow_function(s) 22809 } 22810 } 22811 22812 func (s *Window_functionContext) ExitRule(listener antlr.ParseTreeListener) { 22813 if listenerT, ok := listener.(ParserListener); ok { 22814 listenerT.ExitWindow_function(s) 22815 } 22816 } 22817 22818 func (s *Window_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 22819 switch t := visitor.(type) { 22820 case ParserVisitor: 22821 return t.VisitWindow_function(s) 22822 22823 default: 22824 return t.VisitChildren(s) 22825 } 22826 } 22827 22828 func (p *Parser) Window_function() (localctx IWindow_functionContext) { 22829 this := p 22830 _ = this 22831 22832 localctx = NewWindow_functionContext(p, p.GetParserRuleContext(), p.GetState()) 22833 p.EnterRule(localctx, 150, ParserRULE_window_function) 22834 var _la int 22835 22836 defer func() { 22837 p.ExitRule() 22838 }() 22839 22840 defer func() { 22841 if err := recover(); err != nil { 22842 if v, ok := err.(antlr.RecognitionException); ok { 22843 localctx.SetException(v) 22844 p.GetErrorHandler().ReportError(p, v) 22845 p.GetErrorHandler().Recover(p, v) 22846 } else { 22847 panic(err) 22848 } 22849 } 22850 }() 22851 22852 p.SetState(1971) 22853 p.GetErrorHandler().Sync(p) 22854 22855 switch p.GetTokenStream().LA(1) { 22856 case ParserFIRST_VALUE_, ParserLAST_VALUE_: 22857 p.EnterOuterAlt(localctx, 1) 22858 { 22859 p.SetState(1886) 22860 _la = p.GetTokenStream().LA(1) 22861 22862 if !(_la == ParserFIRST_VALUE_ || _la == ParserLAST_VALUE_) { 22863 p.GetErrorHandler().RecoverInline(p) 22864 } else { 22865 p.GetErrorHandler().ReportMatch(p) 22866 p.Consume() 22867 } 22868 } 22869 { 22870 p.SetState(1887) 22871 p.Match(ParserOPEN_PAR) 22872 } 22873 { 22874 p.SetState(1888) 22875 p.expr(0) 22876 } 22877 { 22878 p.SetState(1889) 22879 p.Match(ParserCLOSE_PAR) 22880 } 22881 { 22882 p.SetState(1890) 22883 p.Match(ParserOVER_) 22884 } 22885 { 22886 p.SetState(1891) 22887 p.Match(ParserOPEN_PAR) 22888 } 22889 p.SetState(1893) 22890 p.GetErrorHandler().Sync(p) 22891 _la = p.GetTokenStream().LA(1) 22892 22893 if _la == ParserPARTITION_ { 22894 { 22895 p.SetState(1892) 22896 p.Partition_by() 22897 } 22898 22899 } 22900 { 22901 p.SetState(1895) 22902 p.Order_by_expr_asc_desc() 22903 } 22904 p.SetState(1897) 22905 p.GetErrorHandler().Sync(p) 22906 _la = p.GetTokenStream().LA(1) 22907 22908 if _la == ParserROWS_ || _la == ParserRANGE_ || _la == ParserGROUPS_ { 22909 { 22910 p.SetState(1896) 22911 p.Frame_clause() 22912 } 22913 22914 } 22915 { 22916 p.SetState(1899) 22917 p.Match(ParserCLOSE_PAR) 22918 } 22919 22920 case ParserCUME_DIST_, ParserPERCENT_RANK_: 22921 p.EnterOuterAlt(localctx, 2) 22922 { 22923 p.SetState(1901) 22924 _la = p.GetTokenStream().LA(1) 22925 22926 if !(_la == ParserCUME_DIST_ || _la == ParserPERCENT_RANK_) { 22927 p.GetErrorHandler().RecoverInline(p) 22928 } else { 22929 p.GetErrorHandler().ReportMatch(p) 22930 p.Consume() 22931 } 22932 } 22933 { 22934 p.SetState(1902) 22935 p.Match(ParserOPEN_PAR) 22936 } 22937 { 22938 p.SetState(1903) 22939 p.Match(ParserCLOSE_PAR) 22940 } 22941 { 22942 p.SetState(1904) 22943 p.Match(ParserOVER_) 22944 } 22945 { 22946 p.SetState(1905) 22947 p.Match(ParserOPEN_PAR) 22948 } 22949 p.SetState(1907) 22950 p.GetErrorHandler().Sync(p) 22951 _la = p.GetTokenStream().LA(1) 22952 22953 if _la == ParserPARTITION_ { 22954 { 22955 p.SetState(1906) 22956 p.Partition_by() 22957 } 22958 22959 } 22960 p.SetState(1910) 22961 p.GetErrorHandler().Sync(p) 22962 _la = p.GetTokenStream().LA(1) 22963 22964 if _la == ParserORDER_ { 22965 { 22966 p.SetState(1909) 22967 p.Order_by_expr() 22968 } 22969 22970 } 22971 { 22972 p.SetState(1912) 22973 p.Match(ParserCLOSE_PAR) 22974 } 22975 22976 case ParserDENSE_RANK_, ParserRANK_, ParserROW_NUMBER_: 22977 p.EnterOuterAlt(localctx, 3) 22978 { 22979 p.SetState(1913) 22980 _la = p.GetTokenStream().LA(1) 22981 22982 if !(((_la-160)&-(0x1f+1)) == 0 && ((1<<uint((_la-160)))&((1<<(ParserDENSE_RANK_-160))|(1<<(ParserRANK_-160))|(1<<(ParserROW_NUMBER_-160)))) != 0) { 22983 p.GetErrorHandler().RecoverInline(p) 22984 } else { 22985 p.GetErrorHandler().ReportMatch(p) 22986 p.Consume() 22987 } 22988 } 22989 { 22990 p.SetState(1914) 22991 p.Match(ParserOPEN_PAR) 22992 } 22993 { 22994 p.SetState(1915) 22995 p.Match(ParserCLOSE_PAR) 22996 } 22997 { 22998 p.SetState(1916) 22999 p.Match(ParserOVER_) 23000 } 23001 { 23002 p.SetState(1917) 23003 p.Match(ParserOPEN_PAR) 23004 } 23005 p.SetState(1919) 23006 p.GetErrorHandler().Sync(p) 23007 _la = p.GetTokenStream().LA(1) 23008 23009 if _la == ParserPARTITION_ { 23010 { 23011 p.SetState(1918) 23012 p.Partition_by() 23013 } 23014 23015 } 23016 { 23017 p.SetState(1921) 23018 p.Order_by_expr_asc_desc() 23019 } 23020 { 23021 p.SetState(1922) 23022 p.Match(ParserCLOSE_PAR) 23023 } 23024 23025 case ParserLAG_, ParserLEAD_: 23026 p.EnterOuterAlt(localctx, 4) 23027 { 23028 p.SetState(1924) 23029 _la = p.GetTokenStream().LA(1) 23030 23031 if !(_la == ParserLAG_ || _la == ParserLEAD_) { 23032 p.GetErrorHandler().RecoverInline(p) 23033 } else { 23034 p.GetErrorHandler().ReportMatch(p) 23035 p.Consume() 23036 } 23037 } 23038 { 23039 p.SetState(1925) 23040 p.Match(ParserOPEN_PAR) 23041 } 23042 { 23043 p.SetState(1926) 23044 p.expr(0) 23045 } 23046 p.SetState(1928) 23047 p.GetErrorHandler().Sync(p) 23048 23049 if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 283, p.GetParserRuleContext()) == 1 { 23050 { 23051 p.SetState(1927) 23052 p.Offset() 23053 } 23054 23055 } 23056 p.SetState(1931) 23057 p.GetErrorHandler().Sync(p) 23058 _la = p.GetTokenStream().LA(1) 23059 23060 if _la == ParserCOMMA { 23061 { 23062 p.SetState(1930) 23063 p.Default_value() 23064 } 23065 23066 } 23067 { 23068 p.SetState(1933) 23069 p.Match(ParserCLOSE_PAR) 23070 } 23071 { 23072 p.SetState(1934) 23073 p.Match(ParserOVER_) 23074 } 23075 { 23076 p.SetState(1935) 23077 p.Match(ParserOPEN_PAR) 23078 } 23079 p.SetState(1937) 23080 p.GetErrorHandler().Sync(p) 23081 _la = p.GetTokenStream().LA(1) 23082 23083 if _la == ParserPARTITION_ { 23084 { 23085 p.SetState(1936) 23086 p.Partition_by() 23087 } 23088 23089 } 23090 { 23091 p.SetState(1939) 23092 p.Order_by_expr_asc_desc() 23093 } 23094 { 23095 p.SetState(1940) 23096 p.Match(ParserCLOSE_PAR) 23097 } 23098 23099 case ParserNTH_VALUE_: 23100 p.EnterOuterAlt(localctx, 5) 23101 { 23102 p.SetState(1942) 23103 p.Match(ParserNTH_VALUE_) 23104 } 23105 { 23106 p.SetState(1943) 23107 p.Match(ParserOPEN_PAR) 23108 } 23109 { 23110 p.SetState(1944) 23111 p.expr(0) 23112 } 23113 { 23114 p.SetState(1945) 23115 p.Match(ParserCOMMA) 23116 } 23117 { 23118 p.SetState(1946) 23119 p.Signed_number() 23120 } 23121 { 23122 p.SetState(1947) 23123 p.Match(ParserCLOSE_PAR) 23124 } 23125 { 23126 p.SetState(1948) 23127 p.Match(ParserOVER_) 23128 } 23129 { 23130 p.SetState(1949) 23131 p.Match(ParserOPEN_PAR) 23132 } 23133 p.SetState(1951) 23134 p.GetErrorHandler().Sync(p) 23135 _la = p.GetTokenStream().LA(1) 23136 23137 if _la == ParserPARTITION_ { 23138 { 23139 p.SetState(1950) 23140 p.Partition_by() 23141 } 23142 23143 } 23144 { 23145 p.SetState(1953) 23146 p.Order_by_expr_asc_desc() 23147 } 23148 p.SetState(1955) 23149 p.GetErrorHandler().Sync(p) 23150 _la = p.GetTokenStream().LA(1) 23151 23152 if _la == ParserROWS_ || _la == ParserRANGE_ || _la == ParserGROUPS_ { 23153 { 23154 p.SetState(1954) 23155 p.Frame_clause() 23156 } 23157 23158 } 23159 { 23160 p.SetState(1957) 23161 p.Match(ParserCLOSE_PAR) 23162 } 23163 23164 case ParserNTILE_: 23165 p.EnterOuterAlt(localctx, 6) 23166 { 23167 p.SetState(1959) 23168 p.Match(ParserNTILE_) 23169 } 23170 { 23171 p.SetState(1960) 23172 p.Match(ParserOPEN_PAR) 23173 } 23174 { 23175 p.SetState(1961) 23176 p.expr(0) 23177 } 23178 { 23179 p.SetState(1962) 23180 p.Match(ParserCLOSE_PAR) 23181 } 23182 { 23183 p.SetState(1963) 23184 p.Match(ParserOVER_) 23185 } 23186 { 23187 p.SetState(1964) 23188 p.Match(ParserOPEN_PAR) 23189 } 23190 p.SetState(1966) 23191 p.GetErrorHandler().Sync(p) 23192 _la = p.GetTokenStream().LA(1) 23193 23194 if _la == ParserPARTITION_ { 23195 { 23196 p.SetState(1965) 23197 p.Partition_by() 23198 } 23199 23200 } 23201 { 23202 p.SetState(1968) 23203 p.Order_by_expr_asc_desc() 23204 } 23205 { 23206 p.SetState(1969) 23207 p.Match(ParserCLOSE_PAR) 23208 } 23209 23210 default: 23211 panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) 23212 } 23213 23214 return localctx 23215 } 23216 23217 // IOffsetContext is an interface to support dynamic dispatch. 23218 type IOffsetContext interface { 23219 antlr.ParserRuleContext 23220 23221 // GetParser returns the parser. 23222 GetParser() antlr.Parser 23223 23224 // IsOffsetContext differentiates from other interfaces. 23225 IsOffsetContext() 23226 } 23227 23228 type OffsetContext struct { 23229 *antlr.BaseParserRuleContext 23230 parser antlr.Parser 23231 } 23232 23233 func NewEmptyOffsetContext() *OffsetContext { 23234 var p = new(OffsetContext) 23235 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 23236 p.RuleIndex = ParserRULE_offset 23237 return p 23238 } 23239 23240 func (*OffsetContext) IsOffsetContext() {} 23241 23242 func NewOffsetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OffsetContext { 23243 var p = new(OffsetContext) 23244 23245 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 23246 23247 p.parser = parser 23248 p.RuleIndex = ParserRULE_offset 23249 23250 return p 23251 } 23252 23253 func (s *OffsetContext) GetParser() antlr.Parser { return s.parser } 23254 23255 func (s *OffsetContext) COMMA() antlr.TerminalNode { 23256 return s.GetToken(ParserCOMMA, 0) 23257 } 23258 23259 func (s *OffsetContext) Signed_number() ISigned_numberContext { 23260 var t antlr.RuleContext 23261 for _, ctx := range s.GetChildren() { 23262 if _, ok := ctx.(ISigned_numberContext); ok { 23263 t = ctx.(antlr.RuleContext) 23264 break 23265 } 23266 } 23267 23268 if t == nil { 23269 return nil 23270 } 23271 23272 return t.(ISigned_numberContext) 23273 } 23274 23275 func (s *OffsetContext) GetRuleContext() antlr.RuleContext { 23276 return s 23277 } 23278 23279 func (s *OffsetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 23280 return antlr.TreesStringTree(s, ruleNames, recog) 23281 } 23282 23283 func (s *OffsetContext) EnterRule(listener antlr.ParseTreeListener) { 23284 if listenerT, ok := listener.(ParserListener); ok { 23285 listenerT.EnterOffset(s) 23286 } 23287 } 23288 23289 func (s *OffsetContext) ExitRule(listener antlr.ParseTreeListener) { 23290 if listenerT, ok := listener.(ParserListener); ok { 23291 listenerT.ExitOffset(s) 23292 } 23293 } 23294 23295 func (s *OffsetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 23296 switch t := visitor.(type) { 23297 case ParserVisitor: 23298 return t.VisitOffset(s) 23299 23300 default: 23301 return t.VisitChildren(s) 23302 } 23303 } 23304 23305 func (p *Parser) Offset() (localctx IOffsetContext) { 23306 this := p 23307 _ = this 23308 23309 localctx = NewOffsetContext(p, p.GetParserRuleContext(), p.GetState()) 23310 p.EnterRule(localctx, 152, ParserRULE_offset) 23311 23312 defer func() { 23313 p.ExitRule() 23314 }() 23315 23316 defer func() { 23317 if err := recover(); err != nil { 23318 if v, ok := err.(antlr.RecognitionException); ok { 23319 localctx.SetException(v) 23320 p.GetErrorHandler().ReportError(p, v) 23321 p.GetErrorHandler().Recover(p, v) 23322 } else { 23323 panic(err) 23324 } 23325 } 23326 }() 23327 23328 p.EnterOuterAlt(localctx, 1) 23329 { 23330 p.SetState(1973) 23331 p.Match(ParserCOMMA) 23332 } 23333 { 23334 p.SetState(1974) 23335 p.Signed_number() 23336 } 23337 23338 return localctx 23339 } 23340 23341 // IDefault_valueContext is an interface to support dynamic dispatch. 23342 type IDefault_valueContext interface { 23343 antlr.ParserRuleContext 23344 23345 // GetParser returns the parser. 23346 GetParser() antlr.Parser 23347 23348 // IsDefault_valueContext differentiates from other interfaces. 23349 IsDefault_valueContext() 23350 } 23351 23352 type Default_valueContext struct { 23353 *antlr.BaseParserRuleContext 23354 parser antlr.Parser 23355 } 23356 23357 func NewEmptyDefault_valueContext() *Default_valueContext { 23358 var p = new(Default_valueContext) 23359 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 23360 p.RuleIndex = ParserRULE_default_value 23361 return p 23362 } 23363 23364 func (*Default_valueContext) IsDefault_valueContext() {} 23365 23366 func NewDefault_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_valueContext { 23367 var p = new(Default_valueContext) 23368 23369 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 23370 23371 p.parser = parser 23372 p.RuleIndex = ParserRULE_default_value 23373 23374 return p 23375 } 23376 23377 func (s *Default_valueContext) GetParser() antlr.Parser { return s.parser } 23378 23379 func (s *Default_valueContext) COMMA() antlr.TerminalNode { 23380 return s.GetToken(ParserCOMMA, 0) 23381 } 23382 23383 func (s *Default_valueContext) Signed_number() ISigned_numberContext { 23384 var t antlr.RuleContext 23385 for _, ctx := range s.GetChildren() { 23386 if _, ok := ctx.(ISigned_numberContext); ok { 23387 t = ctx.(antlr.RuleContext) 23388 break 23389 } 23390 } 23391 23392 if t == nil { 23393 return nil 23394 } 23395 23396 return t.(ISigned_numberContext) 23397 } 23398 23399 func (s *Default_valueContext) GetRuleContext() antlr.RuleContext { 23400 return s 23401 } 23402 23403 func (s *Default_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 23404 return antlr.TreesStringTree(s, ruleNames, recog) 23405 } 23406 23407 func (s *Default_valueContext) EnterRule(listener antlr.ParseTreeListener) { 23408 if listenerT, ok := listener.(ParserListener); ok { 23409 listenerT.EnterDefault_value(s) 23410 } 23411 } 23412 23413 func (s *Default_valueContext) ExitRule(listener antlr.ParseTreeListener) { 23414 if listenerT, ok := listener.(ParserListener); ok { 23415 listenerT.ExitDefault_value(s) 23416 } 23417 } 23418 23419 func (s *Default_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 23420 switch t := visitor.(type) { 23421 case ParserVisitor: 23422 return t.VisitDefault_value(s) 23423 23424 default: 23425 return t.VisitChildren(s) 23426 } 23427 } 23428 23429 func (p *Parser) Default_value() (localctx IDefault_valueContext) { 23430 this := p 23431 _ = this 23432 23433 localctx = NewDefault_valueContext(p, p.GetParserRuleContext(), p.GetState()) 23434 p.EnterRule(localctx, 154, ParserRULE_default_value) 23435 23436 defer func() { 23437 p.ExitRule() 23438 }() 23439 23440 defer func() { 23441 if err := recover(); err != nil { 23442 if v, ok := err.(antlr.RecognitionException); ok { 23443 localctx.SetException(v) 23444 p.GetErrorHandler().ReportError(p, v) 23445 p.GetErrorHandler().Recover(p, v) 23446 } else { 23447 panic(err) 23448 } 23449 } 23450 }() 23451 23452 p.EnterOuterAlt(localctx, 1) 23453 { 23454 p.SetState(1976) 23455 p.Match(ParserCOMMA) 23456 } 23457 { 23458 p.SetState(1977) 23459 p.Signed_number() 23460 } 23461 23462 return localctx 23463 } 23464 23465 // IPartition_byContext is an interface to support dynamic dispatch. 23466 type IPartition_byContext interface { 23467 antlr.ParserRuleContext 23468 23469 // GetParser returns the parser. 23470 GetParser() antlr.Parser 23471 23472 // IsPartition_byContext differentiates from other interfaces. 23473 IsPartition_byContext() 23474 } 23475 23476 type Partition_byContext struct { 23477 *antlr.BaseParserRuleContext 23478 parser antlr.Parser 23479 } 23480 23481 func NewEmptyPartition_byContext() *Partition_byContext { 23482 var p = new(Partition_byContext) 23483 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 23484 p.RuleIndex = ParserRULE_partition_by 23485 return p 23486 } 23487 23488 func (*Partition_byContext) IsPartition_byContext() {} 23489 23490 func NewPartition_byContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_byContext { 23491 var p = new(Partition_byContext) 23492 23493 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 23494 23495 p.parser = parser 23496 p.RuleIndex = ParserRULE_partition_by 23497 23498 return p 23499 } 23500 23501 func (s *Partition_byContext) GetParser() antlr.Parser { return s.parser } 23502 23503 func (s *Partition_byContext) PARTITION_() antlr.TerminalNode { 23504 return s.GetToken(ParserPARTITION_, 0) 23505 } 23506 23507 func (s *Partition_byContext) BY_() antlr.TerminalNode { 23508 return s.GetToken(ParserBY_, 0) 23509 } 23510 23511 func (s *Partition_byContext) AllExpr() []IExprContext { 23512 children := s.GetChildren() 23513 len := 0 23514 for _, ctx := range children { 23515 if _, ok := ctx.(IExprContext); ok { 23516 len++ 23517 } 23518 } 23519 23520 tst := make([]IExprContext, len) 23521 i := 0 23522 for _, ctx := range children { 23523 if t, ok := ctx.(IExprContext); ok { 23524 tst[i] = t.(IExprContext) 23525 i++ 23526 } 23527 } 23528 23529 return tst 23530 } 23531 23532 func (s *Partition_byContext) Expr(i int) IExprContext { 23533 var t antlr.RuleContext 23534 j := 0 23535 for _, ctx := range s.GetChildren() { 23536 if _, ok := ctx.(IExprContext); ok { 23537 if j == i { 23538 t = ctx.(antlr.RuleContext) 23539 break 23540 } 23541 j++ 23542 } 23543 } 23544 23545 if t == nil { 23546 return nil 23547 } 23548 23549 return t.(IExprContext) 23550 } 23551 23552 func (s *Partition_byContext) GetRuleContext() antlr.RuleContext { 23553 return s 23554 } 23555 23556 func (s *Partition_byContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 23557 return antlr.TreesStringTree(s, ruleNames, recog) 23558 } 23559 23560 func (s *Partition_byContext) EnterRule(listener antlr.ParseTreeListener) { 23561 if listenerT, ok := listener.(ParserListener); ok { 23562 listenerT.EnterPartition_by(s) 23563 } 23564 } 23565 23566 func (s *Partition_byContext) ExitRule(listener antlr.ParseTreeListener) { 23567 if listenerT, ok := listener.(ParserListener); ok { 23568 listenerT.ExitPartition_by(s) 23569 } 23570 } 23571 23572 func (s *Partition_byContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 23573 switch t := visitor.(type) { 23574 case ParserVisitor: 23575 return t.VisitPartition_by(s) 23576 23577 default: 23578 return t.VisitChildren(s) 23579 } 23580 } 23581 23582 func (p *Parser) Partition_by() (localctx IPartition_byContext) { 23583 this := p 23584 _ = this 23585 23586 localctx = NewPartition_byContext(p, p.GetParserRuleContext(), p.GetState()) 23587 p.EnterRule(localctx, 156, ParserRULE_partition_by) 23588 23589 defer func() { 23590 p.ExitRule() 23591 }() 23592 23593 defer func() { 23594 if err := recover(); err != nil { 23595 if v, ok := err.(antlr.RecognitionException); ok { 23596 localctx.SetException(v) 23597 p.GetErrorHandler().ReportError(p, v) 23598 p.GetErrorHandler().Recover(p, v) 23599 } else { 23600 panic(err) 23601 } 23602 } 23603 }() 23604 23605 var _alt int 23606 23607 p.EnterOuterAlt(localctx, 1) 23608 { 23609 p.SetState(1979) 23610 p.Match(ParserPARTITION_) 23611 } 23612 { 23613 p.SetState(1980) 23614 p.Match(ParserBY_) 23615 } 23616 p.SetState(1982) 23617 p.GetErrorHandler().Sync(p) 23618 _alt = 1 23619 for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { 23620 switch _alt { 23621 case 1: 23622 { 23623 p.SetState(1981) 23624 p.expr(0) 23625 } 23626 23627 default: 23628 panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) 23629 } 23630 23631 p.SetState(1984) 23632 p.GetErrorHandler().Sync(p) 23633 _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 290, p.GetParserRuleContext()) 23634 } 23635 23636 return localctx 23637 } 23638 23639 // IOrder_by_exprContext is an interface to support dynamic dispatch. 23640 type IOrder_by_exprContext interface { 23641 antlr.ParserRuleContext 23642 23643 // GetParser returns the parser. 23644 GetParser() antlr.Parser 23645 23646 // IsOrder_by_exprContext differentiates from other interfaces. 23647 IsOrder_by_exprContext() 23648 } 23649 23650 type Order_by_exprContext struct { 23651 *antlr.BaseParserRuleContext 23652 parser antlr.Parser 23653 } 23654 23655 func NewEmptyOrder_by_exprContext() *Order_by_exprContext { 23656 var p = new(Order_by_exprContext) 23657 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 23658 p.RuleIndex = ParserRULE_order_by_expr 23659 return p 23660 } 23661 23662 func (*Order_by_exprContext) IsOrder_by_exprContext() {} 23663 23664 func NewOrder_by_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Order_by_exprContext { 23665 var p = new(Order_by_exprContext) 23666 23667 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 23668 23669 p.parser = parser 23670 p.RuleIndex = ParserRULE_order_by_expr 23671 23672 return p 23673 } 23674 23675 func (s *Order_by_exprContext) GetParser() antlr.Parser { return s.parser } 23676 23677 func (s *Order_by_exprContext) ORDER_() antlr.TerminalNode { 23678 return s.GetToken(ParserORDER_, 0) 23679 } 23680 23681 func (s *Order_by_exprContext) BY_() antlr.TerminalNode { 23682 return s.GetToken(ParserBY_, 0) 23683 } 23684 23685 func (s *Order_by_exprContext) AllExpr() []IExprContext { 23686 children := s.GetChildren() 23687 len := 0 23688 for _, ctx := range children { 23689 if _, ok := ctx.(IExprContext); ok { 23690 len++ 23691 } 23692 } 23693 23694 tst := make([]IExprContext, len) 23695 i := 0 23696 for _, ctx := range children { 23697 if t, ok := ctx.(IExprContext); ok { 23698 tst[i] = t.(IExprContext) 23699 i++ 23700 } 23701 } 23702 23703 return tst 23704 } 23705 23706 func (s *Order_by_exprContext) Expr(i int) IExprContext { 23707 var t antlr.RuleContext 23708 j := 0 23709 for _, ctx := range s.GetChildren() { 23710 if _, ok := ctx.(IExprContext); ok { 23711 if j == i { 23712 t = ctx.(antlr.RuleContext) 23713 break 23714 } 23715 j++ 23716 } 23717 } 23718 23719 if t == nil { 23720 return nil 23721 } 23722 23723 return t.(IExprContext) 23724 } 23725 23726 func (s *Order_by_exprContext) GetRuleContext() antlr.RuleContext { 23727 return s 23728 } 23729 23730 func (s *Order_by_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 23731 return antlr.TreesStringTree(s, ruleNames, recog) 23732 } 23733 23734 func (s *Order_by_exprContext) EnterRule(listener antlr.ParseTreeListener) { 23735 if listenerT, ok := listener.(ParserListener); ok { 23736 listenerT.EnterOrder_by_expr(s) 23737 } 23738 } 23739 23740 func (s *Order_by_exprContext) ExitRule(listener antlr.ParseTreeListener) { 23741 if listenerT, ok := listener.(ParserListener); ok { 23742 listenerT.ExitOrder_by_expr(s) 23743 } 23744 } 23745 23746 func (s *Order_by_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 23747 switch t := visitor.(type) { 23748 case ParserVisitor: 23749 return t.VisitOrder_by_expr(s) 23750 23751 default: 23752 return t.VisitChildren(s) 23753 } 23754 } 23755 23756 func (p *Parser) Order_by_expr() (localctx IOrder_by_exprContext) { 23757 this := p 23758 _ = this 23759 23760 localctx = NewOrder_by_exprContext(p, p.GetParserRuleContext(), p.GetState()) 23761 p.EnterRule(localctx, 158, ParserRULE_order_by_expr) 23762 var _la int 23763 23764 defer func() { 23765 p.ExitRule() 23766 }() 23767 23768 defer func() { 23769 if err := recover(); err != nil { 23770 if v, ok := err.(antlr.RecognitionException); ok { 23771 localctx.SetException(v) 23772 p.GetErrorHandler().ReportError(p, v) 23773 p.GetErrorHandler().Recover(p, v) 23774 } else { 23775 panic(err) 23776 } 23777 } 23778 }() 23779 23780 p.EnterOuterAlt(localctx, 1) 23781 { 23782 p.SetState(1986) 23783 p.Match(ParserORDER_) 23784 } 23785 { 23786 p.SetState(1987) 23787 p.Match(ParserBY_) 23788 } 23789 p.SetState(1989) 23790 p.GetErrorHandler().Sync(p) 23791 _la = p.GetTokenStream().LA(1) 23792 23793 for ok := true; ok; ok = (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<ParserOPEN_PAR)|(1<<ParserPLUS)|(1<<ParserMINUS)|(1<<ParserTILDE)|(1<<ParserABORT_)|(1<<ParserACTION_)|(1<<ParserADD_)|(1<<ParserAFTER_)|(1<<ParserALL_)|(1<<ParserALTER_)|(1<<ParserANALYZE_))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(ParserAND_-32))|(1<<(ParserAS_-32))|(1<<(ParserASC_-32))|(1<<(ParserATTACH_-32))|(1<<(ParserAUTOINCREMENT_-32))|(1<<(ParserBEFORE_-32))|(1<<(ParserBEGIN_-32))|(1<<(ParserBETWEEN_-32))|(1<<(ParserBY_-32))|(1<<(ParserCASCADE_-32))|(1<<(ParserCASE_-32))|(1<<(ParserCAST_-32))|(1<<(ParserCHECK_-32))|(1<<(ParserCOLLATE_-32))|(1<<(ParserCOLUMN_-32))|(1<<(ParserCOMMIT_-32))|(1<<(ParserCONFLICT_-32))|(1<<(ParserCONSTRAINT_-32))|(1<<(ParserCREATE_-32))|(1<<(ParserCROSS_-32))|(1<<(ParserCURRENT_DATE_-32))|(1<<(ParserCURRENT_TIME_-32))|(1<<(ParserCURRENT_TIMESTAMP_-32))|(1<<(ParserDATABASE_-32))|(1<<(ParserDEFAULT_-32))|(1<<(ParserDEFERRABLE_-32))|(1<<(ParserDEFERRED_-32))|(1<<(ParserDELETE_-32))|(1<<(ParserDESC_-32))|(1<<(ParserDETACH_-32))|(1<<(ParserDISTINCT_-32))|(1<<(ParserDROP_-32)))) != 0) || (((_la-64)&-(0x1f+1)) == 0 && ((1<<uint((_la-64)))&((1<<(ParserEACH_-64))|(1<<(ParserELSE_-64))|(1<<(ParserEND_-64))|(1<<(ParserESCAPE_-64))|(1<<(ParserEXCEPT_-64))|(1<<(ParserEXCLUSIVE_-64))|(1<<(ParserEXISTS_-64))|(1<<(ParserEXPLAIN_-64))|(1<<(ParserFAIL_-64))|(1<<(ParserFOR_-64))|(1<<(ParserFOREIGN_-64))|(1<<(ParserFROM_-64))|(1<<(ParserFULL_-64))|(1<<(ParserGLOB_-64))|(1<<(ParserGROUP_-64))|(1<<(ParserHAVING_-64))|(1<<(ParserIF_-64))|(1<<(ParserIGNORE_-64))|(1<<(ParserIMMEDIATE_-64))|(1<<(ParserIN_-64))|(1<<(ParserINDEX_-64))|(1<<(ParserINDEXED_-64))|(1<<(ParserINITIALLY_-64))|(1<<(ParserINNER_-64))|(1<<(ParserINSERT_-64))|(1<<(ParserINSTEAD_-64))|(1<<(ParserINTERSECT_-64))|(1<<(ParserINTO_-64))|(1<<(ParserIS_-64))|(1<<(ParserISNULL_-64))|(1<<(ParserJOIN_-64))|(1<<(ParserKEY_-64)))) != 0) || (((_la-96)&-(0x1f+1)) == 0 && ((1<<uint((_la-96)))&((1<<(ParserLEFT_-96))|(1<<(ParserLIKE_-96))|(1<<(ParserLIMIT_-96))|(1<<(ParserMATCH_-96))|(1<<(ParserNATURAL_-96))|(1<<(ParserNO_-96))|(1<<(ParserNOT_-96))|(1<<(ParserNOTNULL_-96))|(1<<(ParserNULL_-96))|(1<<(ParserOF_-96))|(1<<(ParserOFFSET_-96))|(1<<(ParserON_-96))|(1<<(ParserOR_-96))|(1<<(ParserORDER_-96))|(1<<(ParserOUTER_-96))|(1<<(ParserPLAN_-96))|(1<<(ParserPRAGMA_-96))|(1<<(ParserPRIMARY_-96))|(1<<(ParserQUERY_-96))|(1<<(ParserRAISE_-96))|(1<<(ParserRECURSIVE_-96))|(1<<(ParserREFERENCES_-96))|(1<<(ParserREGEXP_-96))|(1<<(ParserREINDEX_-96))|(1<<(ParserRELEASE_-96))|(1<<(ParserRENAME_-96))|(1<<(ParserREPLACE_-96))|(1<<(ParserRESTRICT_-96))|(1<<(ParserRIGHT_-96))|(1<<(ParserROLLBACK_-96))|(1<<(ParserROW_-96)))) != 0) || (((_la-128)&-(0x1f+1)) == 0 && ((1<<uint((_la-128)))&((1<<(ParserROWS_-128))|(1<<(ParserSAVEPOINT_-128))|(1<<(ParserSELECT_-128))|(1<<(ParserSET_-128))|(1<<(ParserTABLE_-128))|(1<<(ParserTEMP_-128))|(1<<(ParserTEMPORARY_-128))|(1<<(ParserTHEN_-128))|(1<<(ParserTO_-128))|(1<<(ParserTRANSACTION_-128))|(1<<(ParserTRIGGER_-128))|(1<<(ParserUNION_-128))|(1<<(ParserUNIQUE_-128))|(1<<(ParserUPDATE_-128))|(1<<(ParserUSING_-128))|(1<<(ParserVACUUM_-128))|(1<<(ParserVALUES_-128))|(1<<(ParserVIEW_-128))|(1<<(ParserVIRTUAL_-128))|(1<<(ParserWHEN_-128))|(1<<(ParserWHERE_-128))|(1<<(ParserWITH_-128))|(1<<(ParserWITHOUT_-128))|(1<<(ParserFIRST_VALUE_-128))|(1<<(ParserOVER_-128))|(1<<(ParserPARTITION_-128))|(1<<(ParserRANGE_-128))|(1<<(ParserPRECEDING_-128))|(1<<(ParserUNBOUNDED_-128))|(1<<(ParserCURRENT_-128))|(1<<(ParserFOLLOWING_-128))|(1<<(ParserCUME_DIST_-128)))) != 0) || (((_la-160)&-(0x1f+1)) == 0 && ((1<<uint((_la-160)))&((1<<(ParserDENSE_RANK_-160))|(1<<(ParserLAG_-160))|(1<<(ParserLAST_VALUE_-160))|(1<<(ParserLEAD_-160))|(1<<(ParserNTH_VALUE_-160))|(1<<(ParserNTILE_-160))|(1<<(ParserPERCENT_RANK_-160))|(1<<(ParserRANK_-160))|(1<<(ParserROW_NUMBER_-160))|(1<<(ParserGENERATED_-160))|(1<<(ParserALWAYS_-160))|(1<<(ParserSTORED_-160))|(1<<(ParserTRUE_-160))|(1<<(ParserFALSE_-160))|(1<<(ParserWINDOW_-160))|(1<<(ParserNULLS_-160))|(1<<(ParserFIRST_-160))|(1<<(ParserLAST_-160))|(1<<(ParserFILTER_-160))|(1<<(ParserGROUPS_-160))|(1<<(ParserEXCLUDE_-160))|(1<<(ParserIDENTIFIER-160))|(1<<(ParserNUMERIC_LITERAL-160))|(1<<(ParserBIND_PARAMETER-160))|(1<<(ParserSTRING_LITERAL-160))|(1<<(ParserBLOB_LITERAL-160)))) != 0) { 23794 { 23795 p.SetState(1988) 23796 p.expr(0) 23797 } 23798 23799 p.SetState(1991) 23800 p.GetErrorHandler().Sync(p) 23801 _la = p.GetTokenStream().LA(1) 23802 } 23803 23804 return localctx 23805 } 23806 23807 // IOrder_by_expr_asc_descContext is an interface to support dynamic dispatch. 23808 type IOrder_by_expr_asc_descContext interface { 23809 antlr.ParserRuleContext 23810 23811 // GetParser returns the parser. 23812 GetParser() antlr.Parser 23813 23814 // IsOrder_by_expr_asc_descContext differentiates from other interfaces. 23815 IsOrder_by_expr_asc_descContext() 23816 } 23817 23818 type Order_by_expr_asc_descContext struct { 23819 *antlr.BaseParserRuleContext 23820 parser antlr.Parser 23821 } 23822 23823 func NewEmptyOrder_by_expr_asc_descContext() *Order_by_expr_asc_descContext { 23824 var p = new(Order_by_expr_asc_descContext) 23825 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 23826 p.RuleIndex = ParserRULE_order_by_expr_asc_desc 23827 return p 23828 } 23829 23830 func (*Order_by_expr_asc_descContext) IsOrder_by_expr_asc_descContext() {} 23831 23832 func NewOrder_by_expr_asc_descContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Order_by_expr_asc_descContext { 23833 var p = new(Order_by_expr_asc_descContext) 23834 23835 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 23836 23837 p.parser = parser 23838 p.RuleIndex = ParserRULE_order_by_expr_asc_desc 23839 23840 return p 23841 } 23842 23843 func (s *Order_by_expr_asc_descContext) GetParser() antlr.Parser { return s.parser } 23844 23845 func (s *Order_by_expr_asc_descContext) ORDER_() antlr.TerminalNode { 23846 return s.GetToken(ParserORDER_, 0) 23847 } 23848 23849 func (s *Order_by_expr_asc_descContext) BY_() antlr.TerminalNode { 23850 return s.GetToken(ParserBY_, 0) 23851 } 23852 23853 func (s *Order_by_expr_asc_descContext) Expr_asc_desc() IExpr_asc_descContext { 23854 var t antlr.RuleContext 23855 for _, ctx := range s.GetChildren() { 23856 if _, ok := ctx.(IExpr_asc_descContext); ok { 23857 t = ctx.(antlr.RuleContext) 23858 break 23859 } 23860 } 23861 23862 if t == nil { 23863 return nil 23864 } 23865 23866 return t.(IExpr_asc_descContext) 23867 } 23868 23869 func (s *Order_by_expr_asc_descContext) GetRuleContext() antlr.RuleContext { 23870 return s 23871 } 23872 23873 func (s *Order_by_expr_asc_descContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 23874 return antlr.TreesStringTree(s, ruleNames, recog) 23875 } 23876 23877 func (s *Order_by_expr_asc_descContext) EnterRule(listener antlr.ParseTreeListener) { 23878 if listenerT, ok := listener.(ParserListener); ok { 23879 listenerT.EnterOrder_by_expr_asc_desc(s) 23880 } 23881 } 23882 23883 func (s *Order_by_expr_asc_descContext) ExitRule(listener antlr.ParseTreeListener) { 23884 if listenerT, ok := listener.(ParserListener); ok { 23885 listenerT.ExitOrder_by_expr_asc_desc(s) 23886 } 23887 } 23888 23889 func (s *Order_by_expr_asc_descContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 23890 switch t := visitor.(type) { 23891 case ParserVisitor: 23892 return t.VisitOrder_by_expr_asc_desc(s) 23893 23894 default: 23895 return t.VisitChildren(s) 23896 } 23897 } 23898 23899 func (p *Parser) Order_by_expr_asc_desc() (localctx IOrder_by_expr_asc_descContext) { 23900 this := p 23901 _ = this 23902 23903 localctx = NewOrder_by_expr_asc_descContext(p, p.GetParserRuleContext(), p.GetState()) 23904 p.EnterRule(localctx, 160, ParserRULE_order_by_expr_asc_desc) 23905 23906 defer func() { 23907 p.ExitRule() 23908 }() 23909 23910 defer func() { 23911 if err := recover(); err != nil { 23912 if v, ok := err.(antlr.RecognitionException); ok { 23913 localctx.SetException(v) 23914 p.GetErrorHandler().ReportError(p, v) 23915 p.GetErrorHandler().Recover(p, v) 23916 } else { 23917 panic(err) 23918 } 23919 } 23920 }() 23921 23922 p.EnterOuterAlt(localctx, 1) 23923 { 23924 p.SetState(1993) 23925 p.Match(ParserORDER_) 23926 } 23927 { 23928 p.SetState(1994) 23929 p.Match(ParserBY_) 23930 } 23931 { 23932 p.SetState(1995) 23933 p.Expr_asc_desc() 23934 } 23935 23936 return localctx 23937 } 23938 23939 // IExpr_asc_descContext is an interface to support dynamic dispatch. 23940 type IExpr_asc_descContext interface { 23941 antlr.ParserRuleContext 23942 23943 // GetParser returns the parser. 23944 GetParser() antlr.Parser 23945 23946 // IsExpr_asc_descContext differentiates from other interfaces. 23947 IsExpr_asc_descContext() 23948 } 23949 23950 type Expr_asc_descContext struct { 23951 *antlr.BaseParserRuleContext 23952 parser antlr.Parser 23953 } 23954 23955 func NewEmptyExpr_asc_descContext() *Expr_asc_descContext { 23956 var p = new(Expr_asc_descContext) 23957 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 23958 p.RuleIndex = ParserRULE_expr_asc_desc 23959 return p 23960 } 23961 23962 func (*Expr_asc_descContext) IsExpr_asc_descContext() {} 23963 23964 func NewExpr_asc_descContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expr_asc_descContext { 23965 var p = new(Expr_asc_descContext) 23966 23967 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 23968 23969 p.parser = parser 23970 p.RuleIndex = ParserRULE_expr_asc_desc 23971 23972 return p 23973 } 23974 23975 func (s *Expr_asc_descContext) GetParser() antlr.Parser { return s.parser } 23976 23977 func (s *Expr_asc_descContext) AllExpr() []IExprContext { 23978 children := s.GetChildren() 23979 len := 0 23980 for _, ctx := range children { 23981 if _, ok := ctx.(IExprContext); ok { 23982 len++ 23983 } 23984 } 23985 23986 tst := make([]IExprContext, len) 23987 i := 0 23988 for _, ctx := range children { 23989 if t, ok := ctx.(IExprContext); ok { 23990 tst[i] = t.(IExprContext) 23991 i++ 23992 } 23993 } 23994 23995 return tst 23996 } 23997 23998 func (s *Expr_asc_descContext) Expr(i int) IExprContext { 23999 var t antlr.RuleContext 24000 j := 0 24001 for _, ctx := range s.GetChildren() { 24002 if _, ok := ctx.(IExprContext); ok { 24003 if j == i { 24004 t = ctx.(antlr.RuleContext) 24005 break 24006 } 24007 j++ 24008 } 24009 } 24010 24011 if t == nil { 24012 return nil 24013 } 24014 24015 return t.(IExprContext) 24016 } 24017 24018 func (s *Expr_asc_descContext) AllAsc_desc() []IAsc_descContext { 24019 children := s.GetChildren() 24020 len := 0 24021 for _, ctx := range children { 24022 if _, ok := ctx.(IAsc_descContext); ok { 24023 len++ 24024 } 24025 } 24026 24027 tst := make([]IAsc_descContext, len) 24028 i := 0 24029 for _, ctx := range children { 24030 if t, ok := ctx.(IAsc_descContext); ok { 24031 tst[i] = t.(IAsc_descContext) 24032 i++ 24033 } 24034 } 24035 24036 return tst 24037 } 24038 24039 func (s *Expr_asc_descContext) Asc_desc(i int) IAsc_descContext { 24040 var t antlr.RuleContext 24041 j := 0 24042 for _, ctx := range s.GetChildren() { 24043 if _, ok := ctx.(IAsc_descContext); ok { 24044 if j == i { 24045 t = ctx.(antlr.RuleContext) 24046 break 24047 } 24048 j++ 24049 } 24050 } 24051 24052 if t == nil { 24053 return nil 24054 } 24055 24056 return t.(IAsc_descContext) 24057 } 24058 24059 func (s *Expr_asc_descContext) AllCOMMA() []antlr.TerminalNode { 24060 return s.GetTokens(ParserCOMMA) 24061 } 24062 24063 func (s *Expr_asc_descContext) COMMA(i int) antlr.TerminalNode { 24064 return s.GetToken(ParserCOMMA, i) 24065 } 24066 24067 func (s *Expr_asc_descContext) GetRuleContext() antlr.RuleContext { 24068 return s 24069 } 24070 24071 func (s *Expr_asc_descContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 24072 return antlr.TreesStringTree(s, ruleNames, recog) 24073 } 24074 24075 func (s *Expr_asc_descContext) EnterRule(listener antlr.ParseTreeListener) { 24076 if listenerT, ok := listener.(ParserListener); ok { 24077 listenerT.EnterExpr_asc_desc(s) 24078 } 24079 } 24080 24081 func (s *Expr_asc_descContext) ExitRule(listener antlr.ParseTreeListener) { 24082 if listenerT, ok := listener.(ParserListener); ok { 24083 listenerT.ExitExpr_asc_desc(s) 24084 } 24085 } 24086 24087 func (s *Expr_asc_descContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 24088 switch t := visitor.(type) { 24089 case ParserVisitor: 24090 return t.VisitExpr_asc_desc(s) 24091 24092 default: 24093 return t.VisitChildren(s) 24094 } 24095 } 24096 24097 func (p *Parser) Expr_asc_desc() (localctx IExpr_asc_descContext) { 24098 this := p 24099 _ = this 24100 24101 localctx = NewExpr_asc_descContext(p, p.GetParserRuleContext(), p.GetState()) 24102 p.EnterRule(localctx, 162, ParserRULE_expr_asc_desc) 24103 var _la int 24104 24105 defer func() { 24106 p.ExitRule() 24107 }() 24108 24109 defer func() { 24110 if err := recover(); err != nil { 24111 if v, ok := err.(antlr.RecognitionException); ok { 24112 localctx.SetException(v) 24113 p.GetErrorHandler().ReportError(p, v) 24114 p.GetErrorHandler().Recover(p, v) 24115 } else { 24116 panic(err) 24117 } 24118 } 24119 }() 24120 24121 p.EnterOuterAlt(localctx, 1) 24122 { 24123 p.SetState(1997) 24124 p.expr(0) 24125 } 24126 p.SetState(1999) 24127 p.GetErrorHandler().Sync(p) 24128 _la = p.GetTokenStream().LA(1) 24129 24130 if _la == ParserASC_ || _la == ParserDESC_ { 24131 { 24132 p.SetState(1998) 24133 p.Asc_desc() 24134 } 24135 24136 } 24137 p.SetState(2008) 24138 p.GetErrorHandler().Sync(p) 24139 _la = p.GetTokenStream().LA(1) 24140 24141 for _la == ParserCOMMA { 24142 { 24143 p.SetState(2001) 24144 p.Match(ParserCOMMA) 24145 } 24146 { 24147 p.SetState(2002) 24148 p.expr(0) 24149 } 24150 p.SetState(2004) 24151 p.GetErrorHandler().Sync(p) 24152 _la = p.GetTokenStream().LA(1) 24153 24154 if _la == ParserASC_ || _la == ParserDESC_ { 24155 { 24156 p.SetState(2003) 24157 p.Asc_desc() 24158 } 24159 24160 } 24161 24162 p.SetState(2010) 24163 p.GetErrorHandler().Sync(p) 24164 _la = p.GetTokenStream().LA(1) 24165 } 24166 24167 return localctx 24168 } 24169 24170 // IInitial_selectContext is an interface to support dynamic dispatch. 24171 type IInitial_selectContext interface { 24172 antlr.ParserRuleContext 24173 24174 // GetParser returns the parser. 24175 GetParser() antlr.Parser 24176 24177 // IsInitial_selectContext differentiates from other interfaces. 24178 IsInitial_selectContext() 24179 } 24180 24181 type Initial_selectContext struct { 24182 *antlr.BaseParserRuleContext 24183 parser antlr.Parser 24184 } 24185 24186 func NewEmptyInitial_selectContext() *Initial_selectContext { 24187 var p = new(Initial_selectContext) 24188 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 24189 p.RuleIndex = ParserRULE_initial_select 24190 return p 24191 } 24192 24193 func (*Initial_selectContext) IsInitial_selectContext() {} 24194 24195 func NewInitial_selectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Initial_selectContext { 24196 var p = new(Initial_selectContext) 24197 24198 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 24199 24200 p.parser = parser 24201 p.RuleIndex = ParserRULE_initial_select 24202 24203 return p 24204 } 24205 24206 func (s *Initial_selectContext) GetParser() antlr.Parser { return s.parser } 24207 24208 func (s *Initial_selectContext) Select_stmt() ISelect_stmtContext { 24209 var t antlr.RuleContext 24210 for _, ctx := range s.GetChildren() { 24211 if _, ok := ctx.(ISelect_stmtContext); ok { 24212 t = ctx.(antlr.RuleContext) 24213 break 24214 } 24215 } 24216 24217 if t == nil { 24218 return nil 24219 } 24220 24221 return t.(ISelect_stmtContext) 24222 } 24223 24224 func (s *Initial_selectContext) GetRuleContext() antlr.RuleContext { 24225 return s 24226 } 24227 24228 func (s *Initial_selectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 24229 return antlr.TreesStringTree(s, ruleNames, recog) 24230 } 24231 24232 func (s *Initial_selectContext) EnterRule(listener antlr.ParseTreeListener) { 24233 if listenerT, ok := listener.(ParserListener); ok { 24234 listenerT.EnterInitial_select(s) 24235 } 24236 } 24237 24238 func (s *Initial_selectContext) ExitRule(listener antlr.ParseTreeListener) { 24239 if listenerT, ok := listener.(ParserListener); ok { 24240 listenerT.ExitInitial_select(s) 24241 } 24242 } 24243 24244 func (s *Initial_selectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 24245 switch t := visitor.(type) { 24246 case ParserVisitor: 24247 return t.VisitInitial_select(s) 24248 24249 default: 24250 return t.VisitChildren(s) 24251 } 24252 } 24253 24254 func (p *Parser) Initial_select() (localctx IInitial_selectContext) { 24255 this := p 24256 _ = this 24257 24258 localctx = NewInitial_selectContext(p, p.GetParserRuleContext(), p.GetState()) 24259 p.EnterRule(localctx, 164, ParserRULE_initial_select) 24260 24261 defer func() { 24262 p.ExitRule() 24263 }() 24264 24265 defer func() { 24266 if err := recover(); err != nil { 24267 if v, ok := err.(antlr.RecognitionException); ok { 24268 localctx.SetException(v) 24269 p.GetErrorHandler().ReportError(p, v) 24270 p.GetErrorHandler().Recover(p, v) 24271 } else { 24272 panic(err) 24273 } 24274 } 24275 }() 24276 24277 p.EnterOuterAlt(localctx, 1) 24278 { 24279 p.SetState(2011) 24280 p.Select_stmt() 24281 } 24282 24283 return localctx 24284 } 24285 24286 // IRecursive_selectContext is an interface to support dynamic dispatch. 24287 type IRecursive_selectContext interface { 24288 antlr.ParserRuleContext 24289 24290 // GetParser returns the parser. 24291 GetParser() antlr.Parser 24292 24293 // IsRecursive_selectContext differentiates from other interfaces. 24294 IsRecursive_selectContext() 24295 } 24296 24297 type Recursive_selectContext struct { 24298 *antlr.BaseParserRuleContext 24299 parser antlr.Parser 24300 } 24301 24302 func NewEmptyRecursive_selectContext() *Recursive_selectContext { 24303 var p = new(Recursive_selectContext) 24304 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 24305 p.RuleIndex = ParserRULE_recursive_select 24306 return p 24307 } 24308 24309 func (*Recursive_selectContext) IsRecursive_selectContext() {} 24310 24311 func NewRecursive_selectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Recursive_selectContext { 24312 var p = new(Recursive_selectContext) 24313 24314 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 24315 24316 p.parser = parser 24317 p.RuleIndex = ParserRULE_recursive_select 24318 24319 return p 24320 } 24321 24322 func (s *Recursive_selectContext) GetParser() antlr.Parser { return s.parser } 24323 24324 func (s *Recursive_selectContext) Select_stmt() ISelect_stmtContext { 24325 var t antlr.RuleContext 24326 for _, ctx := range s.GetChildren() { 24327 if _, ok := ctx.(ISelect_stmtContext); ok { 24328 t = ctx.(antlr.RuleContext) 24329 break 24330 } 24331 } 24332 24333 if t == nil { 24334 return nil 24335 } 24336 24337 return t.(ISelect_stmtContext) 24338 } 24339 24340 func (s *Recursive_selectContext) GetRuleContext() antlr.RuleContext { 24341 return s 24342 } 24343 24344 func (s *Recursive_selectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 24345 return antlr.TreesStringTree(s, ruleNames, recog) 24346 } 24347 24348 func (s *Recursive_selectContext) EnterRule(listener antlr.ParseTreeListener) { 24349 if listenerT, ok := listener.(ParserListener); ok { 24350 listenerT.EnterRecursive_select(s) 24351 } 24352 } 24353 24354 func (s *Recursive_selectContext) ExitRule(listener antlr.ParseTreeListener) { 24355 if listenerT, ok := listener.(ParserListener); ok { 24356 listenerT.ExitRecursive_select(s) 24357 } 24358 } 24359 24360 func (s *Recursive_selectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 24361 switch t := visitor.(type) { 24362 case ParserVisitor: 24363 return t.VisitRecursive_select(s) 24364 24365 default: 24366 return t.VisitChildren(s) 24367 } 24368 } 24369 24370 func (p *Parser) Recursive_select() (localctx IRecursive_selectContext) { 24371 this := p 24372 _ = this 24373 24374 localctx = NewRecursive_selectContext(p, p.GetParserRuleContext(), p.GetState()) 24375 p.EnterRule(localctx, 166, ParserRULE_recursive_select) 24376 24377 defer func() { 24378 p.ExitRule() 24379 }() 24380 24381 defer func() { 24382 if err := recover(); err != nil { 24383 if v, ok := err.(antlr.RecognitionException); ok { 24384 localctx.SetException(v) 24385 p.GetErrorHandler().ReportError(p, v) 24386 p.GetErrorHandler().Recover(p, v) 24387 } else { 24388 panic(err) 24389 } 24390 } 24391 }() 24392 24393 p.EnterOuterAlt(localctx, 1) 24394 { 24395 p.SetState(2013) 24396 p.Select_stmt() 24397 } 24398 24399 return localctx 24400 } 24401 24402 // IUnary_operatorContext is an interface to support dynamic dispatch. 24403 type IUnary_operatorContext interface { 24404 antlr.ParserRuleContext 24405 24406 // GetParser returns the parser. 24407 GetParser() antlr.Parser 24408 24409 // IsUnary_operatorContext differentiates from other interfaces. 24410 IsUnary_operatorContext() 24411 } 24412 24413 type Unary_operatorContext struct { 24414 *antlr.BaseParserRuleContext 24415 parser antlr.Parser 24416 } 24417 24418 func NewEmptyUnary_operatorContext() *Unary_operatorContext { 24419 var p = new(Unary_operatorContext) 24420 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 24421 p.RuleIndex = ParserRULE_unary_operator 24422 return p 24423 } 24424 24425 func (*Unary_operatorContext) IsUnary_operatorContext() {} 24426 24427 func NewUnary_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unary_operatorContext { 24428 var p = new(Unary_operatorContext) 24429 24430 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 24431 24432 p.parser = parser 24433 p.RuleIndex = ParserRULE_unary_operator 24434 24435 return p 24436 } 24437 24438 func (s *Unary_operatorContext) GetParser() antlr.Parser { return s.parser } 24439 24440 func (s *Unary_operatorContext) MINUS() antlr.TerminalNode { 24441 return s.GetToken(ParserMINUS, 0) 24442 } 24443 24444 func (s *Unary_operatorContext) PLUS() antlr.TerminalNode { 24445 return s.GetToken(ParserPLUS, 0) 24446 } 24447 24448 func (s *Unary_operatorContext) TILDE() antlr.TerminalNode { 24449 return s.GetToken(ParserTILDE, 0) 24450 } 24451 24452 func (s *Unary_operatorContext) NOT_() antlr.TerminalNode { 24453 return s.GetToken(ParserNOT_, 0) 24454 } 24455 24456 func (s *Unary_operatorContext) GetRuleContext() antlr.RuleContext { 24457 return s 24458 } 24459 24460 func (s *Unary_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 24461 return antlr.TreesStringTree(s, ruleNames, recog) 24462 } 24463 24464 func (s *Unary_operatorContext) EnterRule(listener antlr.ParseTreeListener) { 24465 if listenerT, ok := listener.(ParserListener); ok { 24466 listenerT.EnterUnary_operator(s) 24467 } 24468 } 24469 24470 func (s *Unary_operatorContext) ExitRule(listener antlr.ParseTreeListener) { 24471 if listenerT, ok := listener.(ParserListener); ok { 24472 listenerT.ExitUnary_operator(s) 24473 } 24474 } 24475 24476 func (s *Unary_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 24477 switch t := visitor.(type) { 24478 case ParserVisitor: 24479 return t.VisitUnary_operator(s) 24480 24481 default: 24482 return t.VisitChildren(s) 24483 } 24484 } 24485 24486 func (p *Parser) Unary_operator() (localctx IUnary_operatorContext) { 24487 this := p 24488 _ = this 24489 24490 localctx = NewUnary_operatorContext(p, p.GetParserRuleContext(), p.GetState()) 24491 p.EnterRule(localctx, 168, ParserRULE_unary_operator) 24492 var _la int 24493 24494 defer func() { 24495 p.ExitRule() 24496 }() 24497 24498 defer func() { 24499 if err := recover(); err != nil { 24500 if v, ok := err.(antlr.RecognitionException); ok { 24501 localctx.SetException(v) 24502 p.GetErrorHandler().ReportError(p, v) 24503 p.GetErrorHandler().Recover(p, v) 24504 } else { 24505 panic(err) 24506 } 24507 } 24508 }() 24509 24510 p.EnterOuterAlt(localctx, 1) 24511 { 24512 p.SetState(2015) 24513 _la = p.GetTokenStream().LA(1) 24514 24515 if !((((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<ParserPLUS)|(1<<ParserMINUS)|(1<<ParserTILDE))) != 0) || _la == ParserNOT_) { 24516 p.GetErrorHandler().RecoverInline(p) 24517 } else { 24518 p.GetErrorHandler().ReportMatch(p) 24519 p.Consume() 24520 } 24521 } 24522 24523 return localctx 24524 } 24525 24526 // IError_messageContext is an interface to support dynamic dispatch. 24527 type IError_messageContext interface { 24528 antlr.ParserRuleContext 24529 24530 // GetParser returns the parser. 24531 GetParser() antlr.Parser 24532 24533 // IsError_messageContext differentiates from other interfaces. 24534 IsError_messageContext() 24535 } 24536 24537 type Error_messageContext struct { 24538 *antlr.BaseParserRuleContext 24539 parser antlr.Parser 24540 } 24541 24542 func NewEmptyError_messageContext() *Error_messageContext { 24543 var p = new(Error_messageContext) 24544 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 24545 p.RuleIndex = ParserRULE_error_message 24546 return p 24547 } 24548 24549 func (*Error_messageContext) IsError_messageContext() {} 24550 24551 func NewError_messageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Error_messageContext { 24552 var p = new(Error_messageContext) 24553 24554 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 24555 24556 p.parser = parser 24557 p.RuleIndex = ParserRULE_error_message 24558 24559 return p 24560 } 24561 24562 func (s *Error_messageContext) GetParser() antlr.Parser { return s.parser } 24563 24564 func (s *Error_messageContext) STRING_LITERAL() antlr.TerminalNode { 24565 return s.GetToken(ParserSTRING_LITERAL, 0) 24566 } 24567 24568 func (s *Error_messageContext) GetRuleContext() antlr.RuleContext { 24569 return s 24570 } 24571 24572 func (s *Error_messageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 24573 return antlr.TreesStringTree(s, ruleNames, recog) 24574 } 24575 24576 func (s *Error_messageContext) EnterRule(listener antlr.ParseTreeListener) { 24577 if listenerT, ok := listener.(ParserListener); ok { 24578 listenerT.EnterError_message(s) 24579 } 24580 } 24581 24582 func (s *Error_messageContext) ExitRule(listener antlr.ParseTreeListener) { 24583 if listenerT, ok := listener.(ParserListener); ok { 24584 listenerT.ExitError_message(s) 24585 } 24586 } 24587 24588 func (s *Error_messageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 24589 switch t := visitor.(type) { 24590 case ParserVisitor: 24591 return t.VisitError_message(s) 24592 24593 default: 24594 return t.VisitChildren(s) 24595 } 24596 } 24597 24598 func (p *Parser) Error_message() (localctx IError_messageContext) { 24599 this := p 24600 _ = this 24601 24602 localctx = NewError_messageContext(p, p.GetParserRuleContext(), p.GetState()) 24603 p.EnterRule(localctx, 170, ParserRULE_error_message) 24604 24605 defer func() { 24606 p.ExitRule() 24607 }() 24608 24609 defer func() { 24610 if err := recover(); err != nil { 24611 if v, ok := err.(antlr.RecognitionException); ok { 24612 localctx.SetException(v) 24613 p.GetErrorHandler().ReportError(p, v) 24614 p.GetErrorHandler().Recover(p, v) 24615 } else { 24616 panic(err) 24617 } 24618 } 24619 }() 24620 24621 p.EnterOuterAlt(localctx, 1) 24622 { 24623 p.SetState(2017) 24624 p.Match(ParserSTRING_LITERAL) 24625 } 24626 24627 return localctx 24628 } 24629 24630 // IModule_argumentContext is an interface to support dynamic dispatch. 24631 type IModule_argumentContext interface { 24632 antlr.ParserRuleContext 24633 24634 // GetParser returns the parser. 24635 GetParser() antlr.Parser 24636 24637 // IsModule_argumentContext differentiates from other interfaces. 24638 IsModule_argumentContext() 24639 } 24640 24641 type Module_argumentContext struct { 24642 *antlr.BaseParserRuleContext 24643 parser antlr.Parser 24644 } 24645 24646 func NewEmptyModule_argumentContext() *Module_argumentContext { 24647 var p = new(Module_argumentContext) 24648 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 24649 p.RuleIndex = ParserRULE_module_argument 24650 return p 24651 } 24652 24653 func (*Module_argumentContext) IsModule_argumentContext() {} 24654 24655 func NewModule_argumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Module_argumentContext { 24656 var p = new(Module_argumentContext) 24657 24658 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 24659 24660 p.parser = parser 24661 p.RuleIndex = ParserRULE_module_argument 24662 24663 return p 24664 } 24665 24666 func (s *Module_argumentContext) GetParser() antlr.Parser { return s.parser } 24667 24668 func (s *Module_argumentContext) Expr() IExprContext { 24669 var t antlr.RuleContext 24670 for _, ctx := range s.GetChildren() { 24671 if _, ok := ctx.(IExprContext); ok { 24672 t = ctx.(antlr.RuleContext) 24673 break 24674 } 24675 } 24676 24677 if t == nil { 24678 return nil 24679 } 24680 24681 return t.(IExprContext) 24682 } 24683 24684 func (s *Module_argumentContext) Column_def() IColumn_defContext { 24685 var t antlr.RuleContext 24686 for _, ctx := range s.GetChildren() { 24687 if _, ok := ctx.(IColumn_defContext); ok { 24688 t = ctx.(antlr.RuleContext) 24689 break 24690 } 24691 } 24692 24693 if t == nil { 24694 return nil 24695 } 24696 24697 return t.(IColumn_defContext) 24698 } 24699 24700 func (s *Module_argumentContext) GetRuleContext() antlr.RuleContext { 24701 return s 24702 } 24703 24704 func (s *Module_argumentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 24705 return antlr.TreesStringTree(s, ruleNames, recog) 24706 } 24707 24708 func (s *Module_argumentContext) EnterRule(listener antlr.ParseTreeListener) { 24709 if listenerT, ok := listener.(ParserListener); ok { 24710 listenerT.EnterModule_argument(s) 24711 } 24712 } 24713 24714 func (s *Module_argumentContext) ExitRule(listener antlr.ParseTreeListener) { 24715 if listenerT, ok := listener.(ParserListener); ok { 24716 listenerT.ExitModule_argument(s) 24717 } 24718 } 24719 24720 func (s *Module_argumentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 24721 switch t := visitor.(type) { 24722 case ParserVisitor: 24723 return t.VisitModule_argument(s) 24724 24725 default: 24726 return t.VisitChildren(s) 24727 } 24728 } 24729 24730 func (p *Parser) Module_argument() (localctx IModule_argumentContext) { 24731 this := p 24732 _ = this 24733 24734 localctx = NewModule_argumentContext(p, p.GetParserRuleContext(), p.GetState()) 24735 p.EnterRule(localctx, 172, ParserRULE_module_argument) 24736 24737 defer func() { 24738 p.ExitRule() 24739 }() 24740 24741 defer func() { 24742 if err := recover(); err != nil { 24743 if v, ok := err.(antlr.RecognitionException); ok { 24744 localctx.SetException(v) 24745 p.GetErrorHandler().ReportError(p, v) 24746 p.GetErrorHandler().Recover(p, v) 24747 } else { 24748 panic(err) 24749 } 24750 } 24751 }() 24752 24753 p.SetState(2021) 24754 p.GetErrorHandler().Sync(p) 24755 switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 295, p.GetParserRuleContext()) { 24756 case 1: 24757 p.EnterOuterAlt(localctx, 1) 24758 { 24759 p.SetState(2019) 24760 p.expr(0) 24761 } 24762 24763 case 2: 24764 p.EnterOuterAlt(localctx, 2) 24765 { 24766 p.SetState(2020) 24767 p.Column_def() 24768 } 24769 24770 } 24771 24772 return localctx 24773 } 24774 24775 // IColumn_aliasContext is an interface to support dynamic dispatch. 24776 type IColumn_aliasContext interface { 24777 antlr.ParserRuleContext 24778 24779 // GetParser returns the parser. 24780 GetParser() antlr.Parser 24781 24782 // IsColumn_aliasContext differentiates from other interfaces. 24783 IsColumn_aliasContext() 24784 } 24785 24786 type Column_aliasContext struct { 24787 *antlr.BaseParserRuleContext 24788 parser antlr.Parser 24789 } 24790 24791 func NewEmptyColumn_aliasContext() *Column_aliasContext { 24792 var p = new(Column_aliasContext) 24793 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 24794 p.RuleIndex = ParserRULE_column_alias 24795 return p 24796 } 24797 24798 func (*Column_aliasContext) IsColumn_aliasContext() {} 24799 24800 func NewColumn_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_aliasContext { 24801 var p = new(Column_aliasContext) 24802 24803 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 24804 24805 p.parser = parser 24806 p.RuleIndex = ParserRULE_column_alias 24807 24808 return p 24809 } 24810 24811 func (s *Column_aliasContext) GetParser() antlr.Parser { return s.parser } 24812 24813 func (s *Column_aliasContext) IDENTIFIER() antlr.TerminalNode { 24814 return s.GetToken(ParserIDENTIFIER, 0) 24815 } 24816 24817 func (s *Column_aliasContext) STRING_LITERAL() antlr.TerminalNode { 24818 return s.GetToken(ParserSTRING_LITERAL, 0) 24819 } 24820 24821 func (s *Column_aliasContext) GetRuleContext() antlr.RuleContext { 24822 return s 24823 } 24824 24825 func (s *Column_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 24826 return antlr.TreesStringTree(s, ruleNames, recog) 24827 } 24828 24829 func (s *Column_aliasContext) EnterRule(listener antlr.ParseTreeListener) { 24830 if listenerT, ok := listener.(ParserListener); ok { 24831 listenerT.EnterColumn_alias(s) 24832 } 24833 } 24834 24835 func (s *Column_aliasContext) ExitRule(listener antlr.ParseTreeListener) { 24836 if listenerT, ok := listener.(ParserListener); ok { 24837 listenerT.ExitColumn_alias(s) 24838 } 24839 } 24840 24841 func (s *Column_aliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 24842 switch t := visitor.(type) { 24843 case ParserVisitor: 24844 return t.VisitColumn_alias(s) 24845 24846 default: 24847 return t.VisitChildren(s) 24848 } 24849 } 24850 24851 func (p *Parser) Column_alias() (localctx IColumn_aliasContext) { 24852 this := p 24853 _ = this 24854 24855 localctx = NewColumn_aliasContext(p, p.GetParserRuleContext(), p.GetState()) 24856 p.EnterRule(localctx, 174, ParserRULE_column_alias) 24857 var _la int 24858 24859 defer func() { 24860 p.ExitRule() 24861 }() 24862 24863 defer func() { 24864 if err := recover(); err != nil { 24865 if v, ok := err.(antlr.RecognitionException); ok { 24866 localctx.SetException(v) 24867 p.GetErrorHandler().ReportError(p, v) 24868 p.GetErrorHandler().Recover(p, v) 24869 } else { 24870 panic(err) 24871 } 24872 } 24873 }() 24874 24875 p.EnterOuterAlt(localctx, 1) 24876 { 24877 p.SetState(2023) 24878 _la = p.GetTokenStream().LA(1) 24879 24880 if !(_la == ParserIDENTIFIER || _la == ParserSTRING_LITERAL) { 24881 p.GetErrorHandler().RecoverInline(p) 24882 } else { 24883 p.GetErrorHandler().ReportMatch(p) 24884 p.Consume() 24885 } 24886 } 24887 24888 return localctx 24889 } 24890 24891 // IKeywordContext is an interface to support dynamic dispatch. 24892 type IKeywordContext interface { 24893 antlr.ParserRuleContext 24894 24895 // GetParser returns the parser. 24896 GetParser() antlr.Parser 24897 24898 // IsKeywordContext differentiates from other interfaces. 24899 IsKeywordContext() 24900 } 24901 24902 type KeywordContext struct { 24903 *antlr.BaseParserRuleContext 24904 parser antlr.Parser 24905 } 24906 24907 func NewEmptyKeywordContext() *KeywordContext { 24908 var p = new(KeywordContext) 24909 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 24910 p.RuleIndex = ParserRULE_keyword 24911 return p 24912 } 24913 24914 func (*KeywordContext) IsKeywordContext() {} 24915 24916 func NewKeywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeywordContext { 24917 var p = new(KeywordContext) 24918 24919 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 24920 24921 p.parser = parser 24922 p.RuleIndex = ParserRULE_keyword 24923 24924 return p 24925 } 24926 24927 func (s *KeywordContext) GetParser() antlr.Parser { return s.parser } 24928 24929 func (s *KeywordContext) ABORT_() antlr.TerminalNode { 24930 return s.GetToken(ParserABORT_, 0) 24931 } 24932 24933 func (s *KeywordContext) ACTION_() antlr.TerminalNode { 24934 return s.GetToken(ParserACTION_, 0) 24935 } 24936 24937 func (s *KeywordContext) ADD_() antlr.TerminalNode { 24938 return s.GetToken(ParserADD_, 0) 24939 } 24940 24941 func (s *KeywordContext) AFTER_() antlr.TerminalNode { 24942 return s.GetToken(ParserAFTER_, 0) 24943 } 24944 24945 func (s *KeywordContext) ALL_() antlr.TerminalNode { 24946 return s.GetToken(ParserALL_, 0) 24947 } 24948 24949 func (s *KeywordContext) ALTER_() antlr.TerminalNode { 24950 return s.GetToken(ParserALTER_, 0) 24951 } 24952 24953 func (s *KeywordContext) ANALYZE_() antlr.TerminalNode { 24954 return s.GetToken(ParserANALYZE_, 0) 24955 } 24956 24957 func (s *KeywordContext) AND_() antlr.TerminalNode { 24958 return s.GetToken(ParserAND_, 0) 24959 } 24960 24961 func (s *KeywordContext) AS_() antlr.TerminalNode { 24962 return s.GetToken(ParserAS_, 0) 24963 } 24964 24965 func (s *KeywordContext) ASC_() antlr.TerminalNode { 24966 return s.GetToken(ParserASC_, 0) 24967 } 24968 24969 func (s *KeywordContext) ATTACH_() antlr.TerminalNode { 24970 return s.GetToken(ParserATTACH_, 0) 24971 } 24972 24973 func (s *KeywordContext) AUTOINCREMENT_() antlr.TerminalNode { 24974 return s.GetToken(ParserAUTOINCREMENT_, 0) 24975 } 24976 24977 func (s *KeywordContext) BEFORE_() antlr.TerminalNode { 24978 return s.GetToken(ParserBEFORE_, 0) 24979 } 24980 24981 func (s *KeywordContext) BEGIN_() antlr.TerminalNode { 24982 return s.GetToken(ParserBEGIN_, 0) 24983 } 24984 24985 func (s *KeywordContext) BETWEEN_() antlr.TerminalNode { 24986 return s.GetToken(ParserBETWEEN_, 0) 24987 } 24988 24989 func (s *KeywordContext) BY_() antlr.TerminalNode { 24990 return s.GetToken(ParserBY_, 0) 24991 } 24992 24993 func (s *KeywordContext) CASCADE_() antlr.TerminalNode { 24994 return s.GetToken(ParserCASCADE_, 0) 24995 } 24996 24997 func (s *KeywordContext) CASE_() antlr.TerminalNode { 24998 return s.GetToken(ParserCASE_, 0) 24999 } 25000 25001 func (s *KeywordContext) CAST_() antlr.TerminalNode { 25002 return s.GetToken(ParserCAST_, 0) 25003 } 25004 25005 func (s *KeywordContext) CHECK_() antlr.TerminalNode { 25006 return s.GetToken(ParserCHECK_, 0) 25007 } 25008 25009 func (s *KeywordContext) COLLATE_() antlr.TerminalNode { 25010 return s.GetToken(ParserCOLLATE_, 0) 25011 } 25012 25013 func (s *KeywordContext) COLUMN_() antlr.TerminalNode { 25014 return s.GetToken(ParserCOLUMN_, 0) 25015 } 25016 25017 func (s *KeywordContext) COMMIT_() antlr.TerminalNode { 25018 return s.GetToken(ParserCOMMIT_, 0) 25019 } 25020 25021 func (s *KeywordContext) CONFLICT_() antlr.TerminalNode { 25022 return s.GetToken(ParserCONFLICT_, 0) 25023 } 25024 25025 func (s *KeywordContext) CONSTRAINT_() antlr.TerminalNode { 25026 return s.GetToken(ParserCONSTRAINT_, 0) 25027 } 25028 25029 func (s *KeywordContext) CREATE_() antlr.TerminalNode { 25030 return s.GetToken(ParserCREATE_, 0) 25031 } 25032 25033 func (s *KeywordContext) CROSS_() antlr.TerminalNode { 25034 return s.GetToken(ParserCROSS_, 0) 25035 } 25036 25037 func (s *KeywordContext) CURRENT_DATE_() antlr.TerminalNode { 25038 return s.GetToken(ParserCURRENT_DATE_, 0) 25039 } 25040 25041 func (s *KeywordContext) CURRENT_TIME_() antlr.TerminalNode { 25042 return s.GetToken(ParserCURRENT_TIME_, 0) 25043 } 25044 25045 func (s *KeywordContext) CURRENT_TIMESTAMP_() antlr.TerminalNode { 25046 return s.GetToken(ParserCURRENT_TIMESTAMP_, 0) 25047 } 25048 25049 func (s *KeywordContext) DATABASE_() antlr.TerminalNode { 25050 return s.GetToken(ParserDATABASE_, 0) 25051 } 25052 25053 func (s *KeywordContext) DEFAULT_() antlr.TerminalNode { 25054 return s.GetToken(ParserDEFAULT_, 0) 25055 } 25056 25057 func (s *KeywordContext) DEFERRABLE_() antlr.TerminalNode { 25058 return s.GetToken(ParserDEFERRABLE_, 0) 25059 } 25060 25061 func (s *KeywordContext) DEFERRED_() antlr.TerminalNode { 25062 return s.GetToken(ParserDEFERRED_, 0) 25063 } 25064 25065 func (s *KeywordContext) DELETE_() antlr.TerminalNode { 25066 return s.GetToken(ParserDELETE_, 0) 25067 } 25068 25069 func (s *KeywordContext) DESC_() antlr.TerminalNode { 25070 return s.GetToken(ParserDESC_, 0) 25071 } 25072 25073 func (s *KeywordContext) DETACH_() antlr.TerminalNode { 25074 return s.GetToken(ParserDETACH_, 0) 25075 } 25076 25077 func (s *KeywordContext) DISTINCT_() antlr.TerminalNode { 25078 return s.GetToken(ParserDISTINCT_, 0) 25079 } 25080 25081 func (s *KeywordContext) DROP_() antlr.TerminalNode { 25082 return s.GetToken(ParserDROP_, 0) 25083 } 25084 25085 func (s *KeywordContext) EACH_() antlr.TerminalNode { 25086 return s.GetToken(ParserEACH_, 0) 25087 } 25088 25089 func (s *KeywordContext) ELSE_() antlr.TerminalNode { 25090 return s.GetToken(ParserELSE_, 0) 25091 } 25092 25093 func (s *KeywordContext) END_() antlr.TerminalNode { 25094 return s.GetToken(ParserEND_, 0) 25095 } 25096 25097 func (s *KeywordContext) ESCAPE_() antlr.TerminalNode { 25098 return s.GetToken(ParserESCAPE_, 0) 25099 } 25100 25101 func (s *KeywordContext) EXCEPT_() antlr.TerminalNode { 25102 return s.GetToken(ParserEXCEPT_, 0) 25103 } 25104 25105 func (s *KeywordContext) EXCLUSIVE_() antlr.TerminalNode { 25106 return s.GetToken(ParserEXCLUSIVE_, 0) 25107 } 25108 25109 func (s *KeywordContext) EXISTS_() antlr.TerminalNode { 25110 return s.GetToken(ParserEXISTS_, 0) 25111 } 25112 25113 func (s *KeywordContext) EXPLAIN_() antlr.TerminalNode { 25114 return s.GetToken(ParserEXPLAIN_, 0) 25115 } 25116 25117 func (s *KeywordContext) FAIL_() antlr.TerminalNode { 25118 return s.GetToken(ParserFAIL_, 0) 25119 } 25120 25121 func (s *KeywordContext) FOR_() antlr.TerminalNode { 25122 return s.GetToken(ParserFOR_, 0) 25123 } 25124 25125 func (s *KeywordContext) FOREIGN_() antlr.TerminalNode { 25126 return s.GetToken(ParserFOREIGN_, 0) 25127 } 25128 25129 func (s *KeywordContext) FROM_() antlr.TerminalNode { 25130 return s.GetToken(ParserFROM_, 0) 25131 } 25132 25133 func (s *KeywordContext) FULL_() antlr.TerminalNode { 25134 return s.GetToken(ParserFULL_, 0) 25135 } 25136 25137 func (s *KeywordContext) GLOB_() antlr.TerminalNode { 25138 return s.GetToken(ParserGLOB_, 0) 25139 } 25140 25141 func (s *KeywordContext) GROUP_() antlr.TerminalNode { 25142 return s.GetToken(ParserGROUP_, 0) 25143 } 25144 25145 func (s *KeywordContext) HAVING_() antlr.TerminalNode { 25146 return s.GetToken(ParserHAVING_, 0) 25147 } 25148 25149 func (s *KeywordContext) IF_() antlr.TerminalNode { 25150 return s.GetToken(ParserIF_, 0) 25151 } 25152 25153 func (s *KeywordContext) IGNORE_() antlr.TerminalNode { 25154 return s.GetToken(ParserIGNORE_, 0) 25155 } 25156 25157 func (s *KeywordContext) IMMEDIATE_() antlr.TerminalNode { 25158 return s.GetToken(ParserIMMEDIATE_, 0) 25159 } 25160 25161 func (s *KeywordContext) IN_() antlr.TerminalNode { 25162 return s.GetToken(ParserIN_, 0) 25163 } 25164 25165 func (s *KeywordContext) INDEX_() antlr.TerminalNode { 25166 return s.GetToken(ParserINDEX_, 0) 25167 } 25168 25169 func (s *KeywordContext) INDEXED_() antlr.TerminalNode { 25170 return s.GetToken(ParserINDEXED_, 0) 25171 } 25172 25173 func (s *KeywordContext) INITIALLY_() antlr.TerminalNode { 25174 return s.GetToken(ParserINITIALLY_, 0) 25175 } 25176 25177 func (s *KeywordContext) INNER_() antlr.TerminalNode { 25178 return s.GetToken(ParserINNER_, 0) 25179 } 25180 25181 func (s *KeywordContext) INSERT_() antlr.TerminalNode { 25182 return s.GetToken(ParserINSERT_, 0) 25183 } 25184 25185 func (s *KeywordContext) INSTEAD_() antlr.TerminalNode { 25186 return s.GetToken(ParserINSTEAD_, 0) 25187 } 25188 25189 func (s *KeywordContext) INTERSECT_() antlr.TerminalNode { 25190 return s.GetToken(ParserINTERSECT_, 0) 25191 } 25192 25193 func (s *KeywordContext) INTO_() antlr.TerminalNode { 25194 return s.GetToken(ParserINTO_, 0) 25195 } 25196 25197 func (s *KeywordContext) IS_() antlr.TerminalNode { 25198 return s.GetToken(ParserIS_, 0) 25199 } 25200 25201 func (s *KeywordContext) ISNULL_() antlr.TerminalNode { 25202 return s.GetToken(ParserISNULL_, 0) 25203 } 25204 25205 func (s *KeywordContext) JOIN_() antlr.TerminalNode { 25206 return s.GetToken(ParserJOIN_, 0) 25207 } 25208 25209 func (s *KeywordContext) KEY_() antlr.TerminalNode { 25210 return s.GetToken(ParserKEY_, 0) 25211 } 25212 25213 func (s *KeywordContext) LEFT_() antlr.TerminalNode { 25214 return s.GetToken(ParserLEFT_, 0) 25215 } 25216 25217 func (s *KeywordContext) LIKE_() antlr.TerminalNode { 25218 return s.GetToken(ParserLIKE_, 0) 25219 } 25220 25221 func (s *KeywordContext) LIMIT_() antlr.TerminalNode { 25222 return s.GetToken(ParserLIMIT_, 0) 25223 } 25224 25225 func (s *KeywordContext) MATCH_() antlr.TerminalNode { 25226 return s.GetToken(ParserMATCH_, 0) 25227 } 25228 25229 func (s *KeywordContext) NATURAL_() antlr.TerminalNode { 25230 return s.GetToken(ParserNATURAL_, 0) 25231 } 25232 25233 func (s *KeywordContext) NO_() antlr.TerminalNode { 25234 return s.GetToken(ParserNO_, 0) 25235 } 25236 25237 func (s *KeywordContext) NOT_() antlr.TerminalNode { 25238 return s.GetToken(ParserNOT_, 0) 25239 } 25240 25241 func (s *KeywordContext) NOTNULL_() antlr.TerminalNode { 25242 return s.GetToken(ParserNOTNULL_, 0) 25243 } 25244 25245 func (s *KeywordContext) NULL_() antlr.TerminalNode { 25246 return s.GetToken(ParserNULL_, 0) 25247 } 25248 25249 func (s *KeywordContext) OF_() antlr.TerminalNode { 25250 return s.GetToken(ParserOF_, 0) 25251 } 25252 25253 func (s *KeywordContext) OFFSET_() antlr.TerminalNode { 25254 return s.GetToken(ParserOFFSET_, 0) 25255 } 25256 25257 func (s *KeywordContext) ON_() antlr.TerminalNode { 25258 return s.GetToken(ParserON_, 0) 25259 } 25260 25261 func (s *KeywordContext) OR_() antlr.TerminalNode { 25262 return s.GetToken(ParserOR_, 0) 25263 } 25264 25265 func (s *KeywordContext) ORDER_() antlr.TerminalNode { 25266 return s.GetToken(ParserORDER_, 0) 25267 } 25268 25269 func (s *KeywordContext) OUTER_() antlr.TerminalNode { 25270 return s.GetToken(ParserOUTER_, 0) 25271 } 25272 25273 func (s *KeywordContext) PLAN_() antlr.TerminalNode { 25274 return s.GetToken(ParserPLAN_, 0) 25275 } 25276 25277 func (s *KeywordContext) PRAGMA_() antlr.TerminalNode { 25278 return s.GetToken(ParserPRAGMA_, 0) 25279 } 25280 25281 func (s *KeywordContext) PRIMARY_() antlr.TerminalNode { 25282 return s.GetToken(ParserPRIMARY_, 0) 25283 } 25284 25285 func (s *KeywordContext) QUERY_() antlr.TerminalNode { 25286 return s.GetToken(ParserQUERY_, 0) 25287 } 25288 25289 func (s *KeywordContext) RAISE_() antlr.TerminalNode { 25290 return s.GetToken(ParserRAISE_, 0) 25291 } 25292 25293 func (s *KeywordContext) RECURSIVE_() antlr.TerminalNode { 25294 return s.GetToken(ParserRECURSIVE_, 0) 25295 } 25296 25297 func (s *KeywordContext) REFERENCES_() antlr.TerminalNode { 25298 return s.GetToken(ParserREFERENCES_, 0) 25299 } 25300 25301 func (s *KeywordContext) REGEXP_() antlr.TerminalNode { 25302 return s.GetToken(ParserREGEXP_, 0) 25303 } 25304 25305 func (s *KeywordContext) REINDEX_() antlr.TerminalNode { 25306 return s.GetToken(ParserREINDEX_, 0) 25307 } 25308 25309 func (s *KeywordContext) RELEASE_() antlr.TerminalNode { 25310 return s.GetToken(ParserRELEASE_, 0) 25311 } 25312 25313 func (s *KeywordContext) RENAME_() antlr.TerminalNode { 25314 return s.GetToken(ParserRENAME_, 0) 25315 } 25316 25317 func (s *KeywordContext) REPLACE_() antlr.TerminalNode { 25318 return s.GetToken(ParserREPLACE_, 0) 25319 } 25320 25321 func (s *KeywordContext) RESTRICT_() antlr.TerminalNode { 25322 return s.GetToken(ParserRESTRICT_, 0) 25323 } 25324 25325 func (s *KeywordContext) RIGHT_() antlr.TerminalNode { 25326 return s.GetToken(ParserRIGHT_, 0) 25327 } 25328 25329 func (s *KeywordContext) ROLLBACK_() antlr.TerminalNode { 25330 return s.GetToken(ParserROLLBACK_, 0) 25331 } 25332 25333 func (s *KeywordContext) ROW_() antlr.TerminalNode { 25334 return s.GetToken(ParserROW_, 0) 25335 } 25336 25337 func (s *KeywordContext) ROWS_() antlr.TerminalNode { 25338 return s.GetToken(ParserROWS_, 0) 25339 } 25340 25341 func (s *KeywordContext) SAVEPOINT_() antlr.TerminalNode { 25342 return s.GetToken(ParserSAVEPOINT_, 0) 25343 } 25344 25345 func (s *KeywordContext) SELECT_() antlr.TerminalNode { 25346 return s.GetToken(ParserSELECT_, 0) 25347 } 25348 25349 func (s *KeywordContext) SET_() antlr.TerminalNode { 25350 return s.GetToken(ParserSET_, 0) 25351 } 25352 25353 func (s *KeywordContext) TABLE_() antlr.TerminalNode { 25354 return s.GetToken(ParserTABLE_, 0) 25355 } 25356 25357 func (s *KeywordContext) TEMP_() antlr.TerminalNode { 25358 return s.GetToken(ParserTEMP_, 0) 25359 } 25360 25361 func (s *KeywordContext) TEMPORARY_() antlr.TerminalNode { 25362 return s.GetToken(ParserTEMPORARY_, 0) 25363 } 25364 25365 func (s *KeywordContext) THEN_() antlr.TerminalNode { 25366 return s.GetToken(ParserTHEN_, 0) 25367 } 25368 25369 func (s *KeywordContext) TO_() antlr.TerminalNode { 25370 return s.GetToken(ParserTO_, 0) 25371 } 25372 25373 func (s *KeywordContext) TRANSACTION_() antlr.TerminalNode { 25374 return s.GetToken(ParserTRANSACTION_, 0) 25375 } 25376 25377 func (s *KeywordContext) TRIGGER_() antlr.TerminalNode { 25378 return s.GetToken(ParserTRIGGER_, 0) 25379 } 25380 25381 func (s *KeywordContext) UNION_() antlr.TerminalNode { 25382 return s.GetToken(ParserUNION_, 0) 25383 } 25384 25385 func (s *KeywordContext) UNIQUE_() antlr.TerminalNode { 25386 return s.GetToken(ParserUNIQUE_, 0) 25387 } 25388 25389 func (s *KeywordContext) UPDATE_() antlr.TerminalNode { 25390 return s.GetToken(ParserUPDATE_, 0) 25391 } 25392 25393 func (s *KeywordContext) USING_() antlr.TerminalNode { 25394 return s.GetToken(ParserUSING_, 0) 25395 } 25396 25397 func (s *KeywordContext) VACUUM_() antlr.TerminalNode { 25398 return s.GetToken(ParserVACUUM_, 0) 25399 } 25400 25401 func (s *KeywordContext) VALUES_() antlr.TerminalNode { 25402 return s.GetToken(ParserVALUES_, 0) 25403 } 25404 25405 func (s *KeywordContext) VIEW_() antlr.TerminalNode { 25406 return s.GetToken(ParserVIEW_, 0) 25407 } 25408 25409 func (s *KeywordContext) VIRTUAL_() antlr.TerminalNode { 25410 return s.GetToken(ParserVIRTUAL_, 0) 25411 } 25412 25413 func (s *KeywordContext) WHEN_() antlr.TerminalNode { 25414 return s.GetToken(ParserWHEN_, 0) 25415 } 25416 25417 func (s *KeywordContext) WHERE_() antlr.TerminalNode { 25418 return s.GetToken(ParserWHERE_, 0) 25419 } 25420 25421 func (s *KeywordContext) WITH_() antlr.TerminalNode { 25422 return s.GetToken(ParserWITH_, 0) 25423 } 25424 25425 func (s *KeywordContext) WITHOUT_() antlr.TerminalNode { 25426 return s.GetToken(ParserWITHOUT_, 0) 25427 } 25428 25429 func (s *KeywordContext) FIRST_VALUE_() antlr.TerminalNode { 25430 return s.GetToken(ParserFIRST_VALUE_, 0) 25431 } 25432 25433 func (s *KeywordContext) OVER_() antlr.TerminalNode { 25434 return s.GetToken(ParserOVER_, 0) 25435 } 25436 25437 func (s *KeywordContext) PARTITION_() antlr.TerminalNode { 25438 return s.GetToken(ParserPARTITION_, 0) 25439 } 25440 25441 func (s *KeywordContext) RANGE_() antlr.TerminalNode { 25442 return s.GetToken(ParserRANGE_, 0) 25443 } 25444 25445 func (s *KeywordContext) PRECEDING_() antlr.TerminalNode { 25446 return s.GetToken(ParserPRECEDING_, 0) 25447 } 25448 25449 func (s *KeywordContext) UNBOUNDED_() antlr.TerminalNode { 25450 return s.GetToken(ParserUNBOUNDED_, 0) 25451 } 25452 25453 func (s *KeywordContext) CURRENT_() antlr.TerminalNode { 25454 return s.GetToken(ParserCURRENT_, 0) 25455 } 25456 25457 func (s *KeywordContext) FOLLOWING_() antlr.TerminalNode { 25458 return s.GetToken(ParserFOLLOWING_, 0) 25459 } 25460 25461 func (s *KeywordContext) CUME_DIST_() antlr.TerminalNode { 25462 return s.GetToken(ParserCUME_DIST_, 0) 25463 } 25464 25465 func (s *KeywordContext) DENSE_RANK_() antlr.TerminalNode { 25466 return s.GetToken(ParserDENSE_RANK_, 0) 25467 } 25468 25469 func (s *KeywordContext) LAG_() antlr.TerminalNode { 25470 return s.GetToken(ParserLAG_, 0) 25471 } 25472 25473 func (s *KeywordContext) LAST_VALUE_() antlr.TerminalNode { 25474 return s.GetToken(ParserLAST_VALUE_, 0) 25475 } 25476 25477 func (s *KeywordContext) LEAD_() antlr.TerminalNode { 25478 return s.GetToken(ParserLEAD_, 0) 25479 } 25480 25481 func (s *KeywordContext) NTH_VALUE_() antlr.TerminalNode { 25482 return s.GetToken(ParserNTH_VALUE_, 0) 25483 } 25484 25485 func (s *KeywordContext) NTILE_() antlr.TerminalNode { 25486 return s.GetToken(ParserNTILE_, 0) 25487 } 25488 25489 func (s *KeywordContext) PERCENT_RANK_() antlr.TerminalNode { 25490 return s.GetToken(ParserPERCENT_RANK_, 0) 25491 } 25492 25493 func (s *KeywordContext) RANK_() antlr.TerminalNode { 25494 return s.GetToken(ParserRANK_, 0) 25495 } 25496 25497 func (s *KeywordContext) ROW_NUMBER_() antlr.TerminalNode { 25498 return s.GetToken(ParserROW_NUMBER_, 0) 25499 } 25500 25501 func (s *KeywordContext) GENERATED_() antlr.TerminalNode { 25502 return s.GetToken(ParserGENERATED_, 0) 25503 } 25504 25505 func (s *KeywordContext) ALWAYS_() antlr.TerminalNode { 25506 return s.GetToken(ParserALWAYS_, 0) 25507 } 25508 25509 func (s *KeywordContext) STORED_() antlr.TerminalNode { 25510 return s.GetToken(ParserSTORED_, 0) 25511 } 25512 25513 func (s *KeywordContext) TRUE_() antlr.TerminalNode { 25514 return s.GetToken(ParserTRUE_, 0) 25515 } 25516 25517 func (s *KeywordContext) FALSE_() antlr.TerminalNode { 25518 return s.GetToken(ParserFALSE_, 0) 25519 } 25520 25521 func (s *KeywordContext) WINDOW_() antlr.TerminalNode { 25522 return s.GetToken(ParserWINDOW_, 0) 25523 } 25524 25525 func (s *KeywordContext) NULLS_() antlr.TerminalNode { 25526 return s.GetToken(ParserNULLS_, 0) 25527 } 25528 25529 func (s *KeywordContext) FIRST_() antlr.TerminalNode { 25530 return s.GetToken(ParserFIRST_, 0) 25531 } 25532 25533 func (s *KeywordContext) LAST_() antlr.TerminalNode { 25534 return s.GetToken(ParserLAST_, 0) 25535 } 25536 25537 func (s *KeywordContext) FILTER_() antlr.TerminalNode { 25538 return s.GetToken(ParserFILTER_, 0) 25539 } 25540 25541 func (s *KeywordContext) GROUPS_() antlr.TerminalNode { 25542 return s.GetToken(ParserGROUPS_, 0) 25543 } 25544 25545 func (s *KeywordContext) EXCLUDE_() antlr.TerminalNode { 25546 return s.GetToken(ParserEXCLUDE_, 0) 25547 } 25548 25549 func (s *KeywordContext) GetRuleContext() antlr.RuleContext { 25550 return s 25551 } 25552 25553 func (s *KeywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 25554 return antlr.TreesStringTree(s, ruleNames, recog) 25555 } 25556 25557 func (s *KeywordContext) EnterRule(listener antlr.ParseTreeListener) { 25558 if listenerT, ok := listener.(ParserListener); ok { 25559 listenerT.EnterKeyword(s) 25560 } 25561 } 25562 25563 func (s *KeywordContext) ExitRule(listener antlr.ParseTreeListener) { 25564 if listenerT, ok := listener.(ParserListener); ok { 25565 listenerT.ExitKeyword(s) 25566 } 25567 } 25568 25569 func (s *KeywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 25570 switch t := visitor.(type) { 25571 case ParserVisitor: 25572 return t.VisitKeyword(s) 25573 25574 default: 25575 return t.VisitChildren(s) 25576 } 25577 } 25578 25579 func (p *Parser) Keyword() (localctx IKeywordContext) { 25580 this := p 25581 _ = this 25582 25583 localctx = NewKeywordContext(p, p.GetParserRuleContext(), p.GetState()) 25584 p.EnterRule(localctx, 176, ParserRULE_keyword) 25585 var _la int 25586 25587 defer func() { 25588 p.ExitRule() 25589 }() 25590 25591 defer func() { 25592 if err := recover(); err != nil { 25593 if v, ok := err.(antlr.RecognitionException); ok { 25594 localctx.SetException(v) 25595 p.GetErrorHandler().ReportError(p, v) 25596 p.GetErrorHandler().Recover(p, v) 25597 } else { 25598 panic(err) 25599 } 25600 } 25601 }() 25602 25603 p.EnterOuterAlt(localctx, 1) 25604 { 25605 p.SetState(2025) 25606 _la = p.GetTokenStream().LA(1) 25607 25608 if !((((_la-25)&-(0x1f+1)) == 0 && ((1<<uint((_la-25)))&((1<<(ParserABORT_-25))|(1<<(ParserACTION_-25))|(1<<(ParserADD_-25))|(1<<(ParserAFTER_-25))|(1<<(ParserALL_-25))|(1<<(ParserALTER_-25))|(1<<(ParserANALYZE_-25))|(1<<(ParserAND_-25))|(1<<(ParserAS_-25))|(1<<(ParserASC_-25))|(1<<(ParserATTACH_-25))|(1<<(ParserAUTOINCREMENT_-25))|(1<<(ParserBEFORE_-25))|(1<<(ParserBEGIN_-25))|(1<<(ParserBETWEEN_-25))|(1<<(ParserBY_-25))|(1<<(ParserCASCADE_-25))|(1<<(ParserCASE_-25))|(1<<(ParserCAST_-25))|(1<<(ParserCHECK_-25))|(1<<(ParserCOLLATE_-25))|(1<<(ParserCOLUMN_-25))|(1<<(ParserCOMMIT_-25))|(1<<(ParserCONFLICT_-25))|(1<<(ParserCONSTRAINT_-25))|(1<<(ParserCREATE_-25))|(1<<(ParserCROSS_-25))|(1<<(ParserCURRENT_DATE_-25))|(1<<(ParserCURRENT_TIME_-25))|(1<<(ParserCURRENT_TIMESTAMP_-25))|(1<<(ParserDATABASE_-25))|(1<<(ParserDEFAULT_-25)))) != 0) || (((_la-57)&-(0x1f+1)) == 0 && ((1<<uint((_la-57)))&((1<<(ParserDEFERRABLE_-57))|(1<<(ParserDEFERRED_-57))|(1<<(ParserDELETE_-57))|(1<<(ParserDESC_-57))|(1<<(ParserDETACH_-57))|(1<<(ParserDISTINCT_-57))|(1<<(ParserDROP_-57))|(1<<(ParserEACH_-57))|(1<<(ParserELSE_-57))|(1<<(ParserEND_-57))|(1<<(ParserESCAPE_-57))|(1<<(ParserEXCEPT_-57))|(1<<(ParserEXCLUSIVE_-57))|(1<<(ParserEXISTS_-57))|(1<<(ParserEXPLAIN_-57))|(1<<(ParserFAIL_-57))|(1<<(ParserFOR_-57))|(1<<(ParserFOREIGN_-57))|(1<<(ParserFROM_-57))|(1<<(ParserFULL_-57))|(1<<(ParserGLOB_-57))|(1<<(ParserGROUP_-57))|(1<<(ParserHAVING_-57))|(1<<(ParserIF_-57))|(1<<(ParserIGNORE_-57))|(1<<(ParserIMMEDIATE_-57))|(1<<(ParserIN_-57))|(1<<(ParserINDEX_-57))|(1<<(ParserINDEXED_-57))|(1<<(ParserINITIALLY_-57))|(1<<(ParserINNER_-57))|(1<<(ParserINSERT_-57)))) != 0) || (((_la-89)&-(0x1f+1)) == 0 && ((1<<uint((_la-89)))&((1<<(ParserINSTEAD_-89))|(1<<(ParserINTERSECT_-89))|(1<<(ParserINTO_-89))|(1<<(ParserIS_-89))|(1<<(ParserISNULL_-89))|(1<<(ParserJOIN_-89))|(1<<(ParserKEY_-89))|(1<<(ParserLEFT_-89))|(1<<(ParserLIKE_-89))|(1<<(ParserLIMIT_-89))|(1<<(ParserMATCH_-89))|(1<<(ParserNATURAL_-89))|(1<<(ParserNO_-89))|(1<<(ParserNOT_-89))|(1<<(ParserNOTNULL_-89))|(1<<(ParserNULL_-89))|(1<<(ParserOF_-89))|(1<<(ParserOFFSET_-89))|(1<<(ParserON_-89))|(1<<(ParserOR_-89))|(1<<(ParserORDER_-89))|(1<<(ParserOUTER_-89))|(1<<(ParserPLAN_-89))|(1<<(ParserPRAGMA_-89))|(1<<(ParserPRIMARY_-89))|(1<<(ParserQUERY_-89))|(1<<(ParserRAISE_-89))|(1<<(ParserRECURSIVE_-89))|(1<<(ParserREFERENCES_-89))|(1<<(ParserREGEXP_-89))|(1<<(ParserREINDEX_-89))|(1<<(ParserRELEASE_-89)))) != 0) || (((_la-121)&-(0x1f+1)) == 0 && ((1<<uint((_la-121)))&((1<<(ParserRENAME_-121))|(1<<(ParserREPLACE_-121))|(1<<(ParserRESTRICT_-121))|(1<<(ParserRIGHT_-121))|(1<<(ParserROLLBACK_-121))|(1<<(ParserROW_-121))|(1<<(ParserROWS_-121))|(1<<(ParserSAVEPOINT_-121))|(1<<(ParserSELECT_-121))|(1<<(ParserSET_-121))|(1<<(ParserTABLE_-121))|(1<<(ParserTEMP_-121))|(1<<(ParserTEMPORARY_-121))|(1<<(ParserTHEN_-121))|(1<<(ParserTO_-121))|(1<<(ParserTRANSACTION_-121))|(1<<(ParserTRIGGER_-121))|(1<<(ParserUNION_-121))|(1<<(ParserUNIQUE_-121))|(1<<(ParserUPDATE_-121))|(1<<(ParserUSING_-121))|(1<<(ParserVACUUM_-121))|(1<<(ParserVALUES_-121))|(1<<(ParserVIEW_-121))|(1<<(ParserVIRTUAL_-121))|(1<<(ParserWHEN_-121))|(1<<(ParserWHERE_-121))|(1<<(ParserWITH_-121))|(1<<(ParserWITHOUT_-121))|(1<<(ParserFIRST_VALUE_-121))|(1<<(ParserOVER_-121)))) != 0) || (((_la-153)&-(0x1f+1)) == 0 && ((1<<uint((_la-153)))&((1<<(ParserPARTITION_-153))|(1<<(ParserRANGE_-153))|(1<<(ParserPRECEDING_-153))|(1<<(ParserUNBOUNDED_-153))|(1<<(ParserCURRENT_-153))|(1<<(ParserFOLLOWING_-153))|(1<<(ParserCUME_DIST_-153))|(1<<(ParserDENSE_RANK_-153))|(1<<(ParserLAG_-153))|(1<<(ParserLAST_VALUE_-153))|(1<<(ParserLEAD_-153))|(1<<(ParserNTH_VALUE_-153))|(1<<(ParserNTILE_-153))|(1<<(ParserPERCENT_RANK_-153))|(1<<(ParserRANK_-153))|(1<<(ParserROW_NUMBER_-153))|(1<<(ParserGENERATED_-153))|(1<<(ParserALWAYS_-153))|(1<<(ParserSTORED_-153))|(1<<(ParserTRUE_-153))|(1<<(ParserFALSE_-153))|(1<<(ParserWINDOW_-153))|(1<<(ParserNULLS_-153))|(1<<(ParserFIRST_-153))|(1<<(ParserLAST_-153))|(1<<(ParserFILTER_-153))|(1<<(ParserGROUPS_-153))|(1<<(ParserEXCLUDE_-153)))) != 0)) { 25609 p.GetErrorHandler().RecoverInline(p) 25610 } else { 25611 p.GetErrorHandler().ReportMatch(p) 25612 p.Consume() 25613 } 25614 } 25615 25616 return localctx 25617 } 25618 25619 // INameContext is an interface to support dynamic dispatch. 25620 type INameContext interface { 25621 antlr.ParserRuleContext 25622 25623 // GetParser returns the parser. 25624 GetParser() antlr.Parser 25625 25626 // IsNameContext differentiates from other interfaces. 25627 IsNameContext() 25628 } 25629 25630 type NameContext struct { 25631 *antlr.BaseParserRuleContext 25632 parser antlr.Parser 25633 } 25634 25635 func NewEmptyNameContext() *NameContext { 25636 var p = new(NameContext) 25637 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 25638 p.RuleIndex = ParserRULE_name 25639 return p 25640 } 25641 25642 func (*NameContext) IsNameContext() {} 25643 25644 func NewNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NameContext { 25645 var p = new(NameContext) 25646 25647 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 25648 25649 p.parser = parser 25650 p.RuleIndex = ParserRULE_name 25651 25652 return p 25653 } 25654 25655 func (s *NameContext) GetParser() antlr.Parser { return s.parser } 25656 25657 func (s *NameContext) Any_name() IAny_nameContext { 25658 var t antlr.RuleContext 25659 for _, ctx := range s.GetChildren() { 25660 if _, ok := ctx.(IAny_nameContext); ok { 25661 t = ctx.(antlr.RuleContext) 25662 break 25663 } 25664 } 25665 25666 if t == nil { 25667 return nil 25668 } 25669 25670 return t.(IAny_nameContext) 25671 } 25672 25673 func (s *NameContext) GetRuleContext() antlr.RuleContext { 25674 return s 25675 } 25676 25677 func (s *NameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 25678 return antlr.TreesStringTree(s, ruleNames, recog) 25679 } 25680 25681 func (s *NameContext) EnterRule(listener antlr.ParseTreeListener) { 25682 if listenerT, ok := listener.(ParserListener); ok { 25683 listenerT.EnterName(s) 25684 } 25685 } 25686 25687 func (s *NameContext) ExitRule(listener antlr.ParseTreeListener) { 25688 if listenerT, ok := listener.(ParserListener); ok { 25689 listenerT.ExitName(s) 25690 } 25691 } 25692 25693 func (s *NameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 25694 switch t := visitor.(type) { 25695 case ParserVisitor: 25696 return t.VisitName(s) 25697 25698 default: 25699 return t.VisitChildren(s) 25700 } 25701 } 25702 25703 func (p *Parser) Name() (localctx INameContext) { 25704 this := p 25705 _ = this 25706 25707 localctx = NewNameContext(p, p.GetParserRuleContext(), p.GetState()) 25708 p.EnterRule(localctx, 178, ParserRULE_name) 25709 25710 defer func() { 25711 p.ExitRule() 25712 }() 25713 25714 defer func() { 25715 if err := recover(); err != nil { 25716 if v, ok := err.(antlr.RecognitionException); ok { 25717 localctx.SetException(v) 25718 p.GetErrorHandler().ReportError(p, v) 25719 p.GetErrorHandler().Recover(p, v) 25720 } else { 25721 panic(err) 25722 } 25723 } 25724 }() 25725 25726 p.EnterOuterAlt(localctx, 1) 25727 { 25728 p.SetState(2027) 25729 p.Any_name() 25730 } 25731 25732 return localctx 25733 } 25734 25735 // IFunction_nameContext is an interface to support dynamic dispatch. 25736 type IFunction_nameContext interface { 25737 antlr.ParserRuleContext 25738 25739 // GetParser returns the parser. 25740 GetParser() antlr.Parser 25741 25742 // IsFunction_nameContext differentiates from other interfaces. 25743 IsFunction_nameContext() 25744 } 25745 25746 type Function_nameContext struct { 25747 *antlr.BaseParserRuleContext 25748 parser antlr.Parser 25749 } 25750 25751 func NewEmptyFunction_nameContext() *Function_nameContext { 25752 var p = new(Function_nameContext) 25753 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 25754 p.RuleIndex = ParserRULE_function_name 25755 return p 25756 } 25757 25758 func (*Function_nameContext) IsFunction_nameContext() {} 25759 25760 func NewFunction_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_nameContext { 25761 var p = new(Function_nameContext) 25762 25763 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 25764 25765 p.parser = parser 25766 p.RuleIndex = ParserRULE_function_name 25767 25768 return p 25769 } 25770 25771 func (s *Function_nameContext) GetParser() antlr.Parser { return s.parser } 25772 25773 func (s *Function_nameContext) Any_name() IAny_nameContext { 25774 var t antlr.RuleContext 25775 for _, ctx := range s.GetChildren() { 25776 if _, ok := ctx.(IAny_nameContext); ok { 25777 t = ctx.(antlr.RuleContext) 25778 break 25779 } 25780 } 25781 25782 if t == nil { 25783 return nil 25784 } 25785 25786 return t.(IAny_nameContext) 25787 } 25788 25789 func (s *Function_nameContext) GetRuleContext() antlr.RuleContext { 25790 return s 25791 } 25792 25793 func (s *Function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 25794 return antlr.TreesStringTree(s, ruleNames, recog) 25795 } 25796 25797 func (s *Function_nameContext) EnterRule(listener antlr.ParseTreeListener) { 25798 if listenerT, ok := listener.(ParserListener); ok { 25799 listenerT.EnterFunction_name(s) 25800 } 25801 } 25802 25803 func (s *Function_nameContext) ExitRule(listener antlr.ParseTreeListener) { 25804 if listenerT, ok := listener.(ParserListener); ok { 25805 listenerT.ExitFunction_name(s) 25806 } 25807 } 25808 25809 func (s *Function_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 25810 switch t := visitor.(type) { 25811 case ParserVisitor: 25812 return t.VisitFunction_name(s) 25813 25814 default: 25815 return t.VisitChildren(s) 25816 } 25817 } 25818 25819 func (p *Parser) Function_name() (localctx IFunction_nameContext) { 25820 this := p 25821 _ = this 25822 25823 localctx = NewFunction_nameContext(p, p.GetParserRuleContext(), p.GetState()) 25824 p.EnterRule(localctx, 180, ParserRULE_function_name) 25825 25826 defer func() { 25827 p.ExitRule() 25828 }() 25829 25830 defer func() { 25831 if err := recover(); err != nil { 25832 if v, ok := err.(antlr.RecognitionException); ok { 25833 localctx.SetException(v) 25834 p.GetErrorHandler().ReportError(p, v) 25835 p.GetErrorHandler().Recover(p, v) 25836 } else { 25837 panic(err) 25838 } 25839 } 25840 }() 25841 25842 p.EnterOuterAlt(localctx, 1) 25843 { 25844 p.SetState(2029) 25845 p.Any_name() 25846 } 25847 25848 return localctx 25849 } 25850 25851 // ISchema_nameContext is an interface to support dynamic dispatch. 25852 type ISchema_nameContext interface { 25853 antlr.ParserRuleContext 25854 25855 // GetParser returns the parser. 25856 GetParser() antlr.Parser 25857 25858 // IsSchema_nameContext differentiates from other interfaces. 25859 IsSchema_nameContext() 25860 } 25861 25862 type Schema_nameContext struct { 25863 *antlr.BaseParserRuleContext 25864 parser antlr.Parser 25865 } 25866 25867 func NewEmptySchema_nameContext() *Schema_nameContext { 25868 var p = new(Schema_nameContext) 25869 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 25870 p.RuleIndex = ParserRULE_schema_name 25871 return p 25872 } 25873 25874 func (*Schema_nameContext) IsSchema_nameContext() {} 25875 25876 func NewSchema_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Schema_nameContext { 25877 var p = new(Schema_nameContext) 25878 25879 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 25880 25881 p.parser = parser 25882 p.RuleIndex = ParserRULE_schema_name 25883 25884 return p 25885 } 25886 25887 func (s *Schema_nameContext) GetParser() antlr.Parser { return s.parser } 25888 25889 func (s *Schema_nameContext) Any_name() IAny_nameContext { 25890 var t antlr.RuleContext 25891 for _, ctx := range s.GetChildren() { 25892 if _, ok := ctx.(IAny_nameContext); ok { 25893 t = ctx.(antlr.RuleContext) 25894 break 25895 } 25896 } 25897 25898 if t == nil { 25899 return nil 25900 } 25901 25902 return t.(IAny_nameContext) 25903 } 25904 25905 func (s *Schema_nameContext) GetRuleContext() antlr.RuleContext { 25906 return s 25907 } 25908 25909 func (s *Schema_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 25910 return antlr.TreesStringTree(s, ruleNames, recog) 25911 } 25912 25913 func (s *Schema_nameContext) EnterRule(listener antlr.ParseTreeListener) { 25914 if listenerT, ok := listener.(ParserListener); ok { 25915 listenerT.EnterSchema_name(s) 25916 } 25917 } 25918 25919 func (s *Schema_nameContext) ExitRule(listener antlr.ParseTreeListener) { 25920 if listenerT, ok := listener.(ParserListener); ok { 25921 listenerT.ExitSchema_name(s) 25922 } 25923 } 25924 25925 func (s *Schema_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 25926 switch t := visitor.(type) { 25927 case ParserVisitor: 25928 return t.VisitSchema_name(s) 25929 25930 default: 25931 return t.VisitChildren(s) 25932 } 25933 } 25934 25935 func (p *Parser) Schema_name() (localctx ISchema_nameContext) { 25936 this := p 25937 _ = this 25938 25939 localctx = NewSchema_nameContext(p, p.GetParserRuleContext(), p.GetState()) 25940 p.EnterRule(localctx, 182, ParserRULE_schema_name) 25941 25942 defer func() { 25943 p.ExitRule() 25944 }() 25945 25946 defer func() { 25947 if err := recover(); err != nil { 25948 if v, ok := err.(antlr.RecognitionException); ok { 25949 localctx.SetException(v) 25950 p.GetErrorHandler().ReportError(p, v) 25951 p.GetErrorHandler().Recover(p, v) 25952 } else { 25953 panic(err) 25954 } 25955 } 25956 }() 25957 25958 p.EnterOuterAlt(localctx, 1) 25959 { 25960 p.SetState(2031) 25961 p.Any_name() 25962 } 25963 25964 return localctx 25965 } 25966 25967 // ITable_nameContext is an interface to support dynamic dispatch. 25968 type ITable_nameContext interface { 25969 antlr.ParserRuleContext 25970 25971 // GetParser returns the parser. 25972 GetParser() antlr.Parser 25973 25974 // IsTable_nameContext differentiates from other interfaces. 25975 IsTable_nameContext() 25976 } 25977 25978 type Table_nameContext struct { 25979 *antlr.BaseParserRuleContext 25980 parser antlr.Parser 25981 } 25982 25983 func NewEmptyTable_nameContext() *Table_nameContext { 25984 var p = new(Table_nameContext) 25985 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 25986 p.RuleIndex = ParserRULE_table_name 25987 return p 25988 } 25989 25990 func (*Table_nameContext) IsTable_nameContext() {} 25991 25992 func NewTable_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_nameContext { 25993 var p = new(Table_nameContext) 25994 25995 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 25996 25997 p.parser = parser 25998 p.RuleIndex = ParserRULE_table_name 25999 26000 return p 26001 } 26002 26003 func (s *Table_nameContext) GetParser() antlr.Parser { return s.parser } 26004 26005 func (s *Table_nameContext) Any_name() IAny_nameContext { 26006 var t antlr.RuleContext 26007 for _, ctx := range s.GetChildren() { 26008 if _, ok := ctx.(IAny_nameContext); ok { 26009 t = ctx.(antlr.RuleContext) 26010 break 26011 } 26012 } 26013 26014 if t == nil { 26015 return nil 26016 } 26017 26018 return t.(IAny_nameContext) 26019 } 26020 26021 func (s *Table_nameContext) GetRuleContext() antlr.RuleContext { 26022 return s 26023 } 26024 26025 func (s *Table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 26026 return antlr.TreesStringTree(s, ruleNames, recog) 26027 } 26028 26029 func (s *Table_nameContext) EnterRule(listener antlr.ParseTreeListener) { 26030 if listenerT, ok := listener.(ParserListener); ok { 26031 listenerT.EnterTable_name(s) 26032 } 26033 } 26034 26035 func (s *Table_nameContext) ExitRule(listener antlr.ParseTreeListener) { 26036 if listenerT, ok := listener.(ParserListener); ok { 26037 listenerT.ExitTable_name(s) 26038 } 26039 } 26040 26041 func (s *Table_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 26042 switch t := visitor.(type) { 26043 case ParserVisitor: 26044 return t.VisitTable_name(s) 26045 26046 default: 26047 return t.VisitChildren(s) 26048 } 26049 } 26050 26051 func (p *Parser) Table_name() (localctx ITable_nameContext) { 26052 this := p 26053 _ = this 26054 26055 localctx = NewTable_nameContext(p, p.GetParserRuleContext(), p.GetState()) 26056 p.EnterRule(localctx, 184, ParserRULE_table_name) 26057 26058 defer func() { 26059 p.ExitRule() 26060 }() 26061 26062 defer func() { 26063 if err := recover(); err != nil { 26064 if v, ok := err.(antlr.RecognitionException); ok { 26065 localctx.SetException(v) 26066 p.GetErrorHandler().ReportError(p, v) 26067 p.GetErrorHandler().Recover(p, v) 26068 } else { 26069 panic(err) 26070 } 26071 } 26072 }() 26073 26074 p.EnterOuterAlt(localctx, 1) 26075 { 26076 p.SetState(2033) 26077 p.Any_name() 26078 } 26079 26080 return localctx 26081 } 26082 26083 // ITable_or_index_nameContext is an interface to support dynamic dispatch. 26084 type ITable_or_index_nameContext interface { 26085 antlr.ParserRuleContext 26086 26087 // GetParser returns the parser. 26088 GetParser() antlr.Parser 26089 26090 // IsTable_or_index_nameContext differentiates from other interfaces. 26091 IsTable_or_index_nameContext() 26092 } 26093 26094 type Table_or_index_nameContext struct { 26095 *antlr.BaseParserRuleContext 26096 parser antlr.Parser 26097 } 26098 26099 func NewEmptyTable_or_index_nameContext() *Table_or_index_nameContext { 26100 var p = new(Table_or_index_nameContext) 26101 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 26102 p.RuleIndex = ParserRULE_table_or_index_name 26103 return p 26104 } 26105 26106 func (*Table_or_index_nameContext) IsTable_or_index_nameContext() {} 26107 26108 func NewTable_or_index_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_or_index_nameContext { 26109 var p = new(Table_or_index_nameContext) 26110 26111 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 26112 26113 p.parser = parser 26114 p.RuleIndex = ParserRULE_table_or_index_name 26115 26116 return p 26117 } 26118 26119 func (s *Table_or_index_nameContext) GetParser() antlr.Parser { return s.parser } 26120 26121 func (s *Table_or_index_nameContext) Any_name() IAny_nameContext { 26122 var t antlr.RuleContext 26123 for _, ctx := range s.GetChildren() { 26124 if _, ok := ctx.(IAny_nameContext); ok { 26125 t = ctx.(antlr.RuleContext) 26126 break 26127 } 26128 } 26129 26130 if t == nil { 26131 return nil 26132 } 26133 26134 return t.(IAny_nameContext) 26135 } 26136 26137 func (s *Table_or_index_nameContext) GetRuleContext() antlr.RuleContext { 26138 return s 26139 } 26140 26141 func (s *Table_or_index_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 26142 return antlr.TreesStringTree(s, ruleNames, recog) 26143 } 26144 26145 func (s *Table_or_index_nameContext) EnterRule(listener antlr.ParseTreeListener) { 26146 if listenerT, ok := listener.(ParserListener); ok { 26147 listenerT.EnterTable_or_index_name(s) 26148 } 26149 } 26150 26151 func (s *Table_or_index_nameContext) ExitRule(listener antlr.ParseTreeListener) { 26152 if listenerT, ok := listener.(ParserListener); ok { 26153 listenerT.ExitTable_or_index_name(s) 26154 } 26155 } 26156 26157 func (s *Table_or_index_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 26158 switch t := visitor.(type) { 26159 case ParserVisitor: 26160 return t.VisitTable_or_index_name(s) 26161 26162 default: 26163 return t.VisitChildren(s) 26164 } 26165 } 26166 26167 func (p *Parser) Table_or_index_name() (localctx ITable_or_index_nameContext) { 26168 this := p 26169 _ = this 26170 26171 localctx = NewTable_or_index_nameContext(p, p.GetParserRuleContext(), p.GetState()) 26172 p.EnterRule(localctx, 186, ParserRULE_table_or_index_name) 26173 26174 defer func() { 26175 p.ExitRule() 26176 }() 26177 26178 defer func() { 26179 if err := recover(); err != nil { 26180 if v, ok := err.(antlr.RecognitionException); ok { 26181 localctx.SetException(v) 26182 p.GetErrorHandler().ReportError(p, v) 26183 p.GetErrorHandler().Recover(p, v) 26184 } else { 26185 panic(err) 26186 } 26187 } 26188 }() 26189 26190 p.EnterOuterAlt(localctx, 1) 26191 { 26192 p.SetState(2035) 26193 p.Any_name() 26194 } 26195 26196 return localctx 26197 } 26198 26199 // IColumn_nameContext is an interface to support dynamic dispatch. 26200 type IColumn_nameContext interface { 26201 antlr.ParserRuleContext 26202 26203 // GetParser returns the parser. 26204 GetParser() antlr.Parser 26205 26206 // IsColumn_nameContext differentiates from other interfaces. 26207 IsColumn_nameContext() 26208 } 26209 26210 type Column_nameContext struct { 26211 *antlr.BaseParserRuleContext 26212 parser antlr.Parser 26213 } 26214 26215 func NewEmptyColumn_nameContext() *Column_nameContext { 26216 var p = new(Column_nameContext) 26217 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 26218 p.RuleIndex = ParserRULE_column_name 26219 return p 26220 } 26221 26222 func (*Column_nameContext) IsColumn_nameContext() {} 26223 26224 func NewColumn_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_nameContext { 26225 var p = new(Column_nameContext) 26226 26227 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 26228 26229 p.parser = parser 26230 p.RuleIndex = ParserRULE_column_name 26231 26232 return p 26233 } 26234 26235 func (s *Column_nameContext) GetParser() antlr.Parser { return s.parser } 26236 26237 func (s *Column_nameContext) Any_name() IAny_nameContext { 26238 var t antlr.RuleContext 26239 for _, ctx := range s.GetChildren() { 26240 if _, ok := ctx.(IAny_nameContext); ok { 26241 t = ctx.(antlr.RuleContext) 26242 break 26243 } 26244 } 26245 26246 if t == nil { 26247 return nil 26248 } 26249 26250 return t.(IAny_nameContext) 26251 } 26252 26253 func (s *Column_nameContext) GetRuleContext() antlr.RuleContext { 26254 return s 26255 } 26256 26257 func (s *Column_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 26258 return antlr.TreesStringTree(s, ruleNames, recog) 26259 } 26260 26261 func (s *Column_nameContext) EnterRule(listener antlr.ParseTreeListener) { 26262 if listenerT, ok := listener.(ParserListener); ok { 26263 listenerT.EnterColumn_name(s) 26264 } 26265 } 26266 26267 func (s *Column_nameContext) ExitRule(listener antlr.ParseTreeListener) { 26268 if listenerT, ok := listener.(ParserListener); ok { 26269 listenerT.ExitColumn_name(s) 26270 } 26271 } 26272 26273 func (s *Column_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 26274 switch t := visitor.(type) { 26275 case ParserVisitor: 26276 return t.VisitColumn_name(s) 26277 26278 default: 26279 return t.VisitChildren(s) 26280 } 26281 } 26282 26283 func (p *Parser) Column_name() (localctx IColumn_nameContext) { 26284 this := p 26285 _ = this 26286 26287 localctx = NewColumn_nameContext(p, p.GetParserRuleContext(), p.GetState()) 26288 p.EnterRule(localctx, 188, ParserRULE_column_name) 26289 26290 defer func() { 26291 p.ExitRule() 26292 }() 26293 26294 defer func() { 26295 if err := recover(); err != nil { 26296 if v, ok := err.(antlr.RecognitionException); ok { 26297 localctx.SetException(v) 26298 p.GetErrorHandler().ReportError(p, v) 26299 p.GetErrorHandler().Recover(p, v) 26300 } else { 26301 panic(err) 26302 } 26303 } 26304 }() 26305 26306 p.EnterOuterAlt(localctx, 1) 26307 { 26308 p.SetState(2037) 26309 p.Any_name() 26310 } 26311 26312 return localctx 26313 } 26314 26315 // ICollation_nameContext is an interface to support dynamic dispatch. 26316 type ICollation_nameContext interface { 26317 antlr.ParserRuleContext 26318 26319 // GetParser returns the parser. 26320 GetParser() antlr.Parser 26321 26322 // IsCollation_nameContext differentiates from other interfaces. 26323 IsCollation_nameContext() 26324 } 26325 26326 type Collation_nameContext struct { 26327 *antlr.BaseParserRuleContext 26328 parser antlr.Parser 26329 } 26330 26331 func NewEmptyCollation_nameContext() *Collation_nameContext { 26332 var p = new(Collation_nameContext) 26333 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 26334 p.RuleIndex = ParserRULE_collation_name 26335 return p 26336 } 26337 26338 func (*Collation_nameContext) IsCollation_nameContext() {} 26339 26340 func NewCollation_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Collation_nameContext { 26341 var p = new(Collation_nameContext) 26342 26343 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 26344 26345 p.parser = parser 26346 p.RuleIndex = ParserRULE_collation_name 26347 26348 return p 26349 } 26350 26351 func (s *Collation_nameContext) GetParser() antlr.Parser { return s.parser } 26352 26353 func (s *Collation_nameContext) Any_name() IAny_nameContext { 26354 var t antlr.RuleContext 26355 for _, ctx := range s.GetChildren() { 26356 if _, ok := ctx.(IAny_nameContext); ok { 26357 t = ctx.(antlr.RuleContext) 26358 break 26359 } 26360 } 26361 26362 if t == nil { 26363 return nil 26364 } 26365 26366 return t.(IAny_nameContext) 26367 } 26368 26369 func (s *Collation_nameContext) GetRuleContext() antlr.RuleContext { 26370 return s 26371 } 26372 26373 func (s *Collation_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 26374 return antlr.TreesStringTree(s, ruleNames, recog) 26375 } 26376 26377 func (s *Collation_nameContext) EnterRule(listener antlr.ParseTreeListener) { 26378 if listenerT, ok := listener.(ParserListener); ok { 26379 listenerT.EnterCollation_name(s) 26380 } 26381 } 26382 26383 func (s *Collation_nameContext) ExitRule(listener antlr.ParseTreeListener) { 26384 if listenerT, ok := listener.(ParserListener); ok { 26385 listenerT.ExitCollation_name(s) 26386 } 26387 } 26388 26389 func (s *Collation_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 26390 switch t := visitor.(type) { 26391 case ParserVisitor: 26392 return t.VisitCollation_name(s) 26393 26394 default: 26395 return t.VisitChildren(s) 26396 } 26397 } 26398 26399 func (p *Parser) Collation_name() (localctx ICollation_nameContext) { 26400 this := p 26401 _ = this 26402 26403 localctx = NewCollation_nameContext(p, p.GetParserRuleContext(), p.GetState()) 26404 p.EnterRule(localctx, 190, ParserRULE_collation_name) 26405 26406 defer func() { 26407 p.ExitRule() 26408 }() 26409 26410 defer func() { 26411 if err := recover(); err != nil { 26412 if v, ok := err.(antlr.RecognitionException); ok { 26413 localctx.SetException(v) 26414 p.GetErrorHandler().ReportError(p, v) 26415 p.GetErrorHandler().Recover(p, v) 26416 } else { 26417 panic(err) 26418 } 26419 } 26420 }() 26421 26422 p.EnterOuterAlt(localctx, 1) 26423 { 26424 p.SetState(2039) 26425 p.Any_name() 26426 } 26427 26428 return localctx 26429 } 26430 26431 // IForeign_tableContext is an interface to support dynamic dispatch. 26432 type IForeign_tableContext interface { 26433 antlr.ParserRuleContext 26434 26435 // GetParser returns the parser. 26436 GetParser() antlr.Parser 26437 26438 // IsForeign_tableContext differentiates from other interfaces. 26439 IsForeign_tableContext() 26440 } 26441 26442 type Foreign_tableContext struct { 26443 *antlr.BaseParserRuleContext 26444 parser antlr.Parser 26445 } 26446 26447 func NewEmptyForeign_tableContext() *Foreign_tableContext { 26448 var p = new(Foreign_tableContext) 26449 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 26450 p.RuleIndex = ParserRULE_foreign_table 26451 return p 26452 } 26453 26454 func (*Foreign_tableContext) IsForeign_tableContext() {} 26455 26456 func NewForeign_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Foreign_tableContext { 26457 var p = new(Foreign_tableContext) 26458 26459 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 26460 26461 p.parser = parser 26462 p.RuleIndex = ParserRULE_foreign_table 26463 26464 return p 26465 } 26466 26467 func (s *Foreign_tableContext) GetParser() antlr.Parser { return s.parser } 26468 26469 func (s *Foreign_tableContext) Any_name() IAny_nameContext { 26470 var t antlr.RuleContext 26471 for _, ctx := range s.GetChildren() { 26472 if _, ok := ctx.(IAny_nameContext); ok { 26473 t = ctx.(antlr.RuleContext) 26474 break 26475 } 26476 } 26477 26478 if t == nil { 26479 return nil 26480 } 26481 26482 return t.(IAny_nameContext) 26483 } 26484 26485 func (s *Foreign_tableContext) GetRuleContext() antlr.RuleContext { 26486 return s 26487 } 26488 26489 func (s *Foreign_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 26490 return antlr.TreesStringTree(s, ruleNames, recog) 26491 } 26492 26493 func (s *Foreign_tableContext) EnterRule(listener antlr.ParseTreeListener) { 26494 if listenerT, ok := listener.(ParserListener); ok { 26495 listenerT.EnterForeign_table(s) 26496 } 26497 } 26498 26499 func (s *Foreign_tableContext) ExitRule(listener antlr.ParseTreeListener) { 26500 if listenerT, ok := listener.(ParserListener); ok { 26501 listenerT.ExitForeign_table(s) 26502 } 26503 } 26504 26505 func (s *Foreign_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 26506 switch t := visitor.(type) { 26507 case ParserVisitor: 26508 return t.VisitForeign_table(s) 26509 26510 default: 26511 return t.VisitChildren(s) 26512 } 26513 } 26514 26515 func (p *Parser) Foreign_table() (localctx IForeign_tableContext) { 26516 this := p 26517 _ = this 26518 26519 localctx = NewForeign_tableContext(p, p.GetParserRuleContext(), p.GetState()) 26520 p.EnterRule(localctx, 192, ParserRULE_foreign_table) 26521 26522 defer func() { 26523 p.ExitRule() 26524 }() 26525 26526 defer func() { 26527 if err := recover(); err != nil { 26528 if v, ok := err.(antlr.RecognitionException); ok { 26529 localctx.SetException(v) 26530 p.GetErrorHandler().ReportError(p, v) 26531 p.GetErrorHandler().Recover(p, v) 26532 } else { 26533 panic(err) 26534 } 26535 } 26536 }() 26537 26538 p.EnterOuterAlt(localctx, 1) 26539 { 26540 p.SetState(2041) 26541 p.Any_name() 26542 } 26543 26544 return localctx 26545 } 26546 26547 // IIndex_nameContext is an interface to support dynamic dispatch. 26548 type IIndex_nameContext interface { 26549 antlr.ParserRuleContext 26550 26551 // GetParser returns the parser. 26552 GetParser() antlr.Parser 26553 26554 // IsIndex_nameContext differentiates from other interfaces. 26555 IsIndex_nameContext() 26556 } 26557 26558 type Index_nameContext struct { 26559 *antlr.BaseParserRuleContext 26560 parser antlr.Parser 26561 } 26562 26563 func NewEmptyIndex_nameContext() *Index_nameContext { 26564 var p = new(Index_nameContext) 26565 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 26566 p.RuleIndex = ParserRULE_index_name 26567 return p 26568 } 26569 26570 func (*Index_nameContext) IsIndex_nameContext() {} 26571 26572 func NewIndex_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_nameContext { 26573 var p = new(Index_nameContext) 26574 26575 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 26576 26577 p.parser = parser 26578 p.RuleIndex = ParserRULE_index_name 26579 26580 return p 26581 } 26582 26583 func (s *Index_nameContext) GetParser() antlr.Parser { return s.parser } 26584 26585 func (s *Index_nameContext) Any_name() IAny_nameContext { 26586 var t antlr.RuleContext 26587 for _, ctx := range s.GetChildren() { 26588 if _, ok := ctx.(IAny_nameContext); ok { 26589 t = ctx.(antlr.RuleContext) 26590 break 26591 } 26592 } 26593 26594 if t == nil { 26595 return nil 26596 } 26597 26598 return t.(IAny_nameContext) 26599 } 26600 26601 func (s *Index_nameContext) GetRuleContext() antlr.RuleContext { 26602 return s 26603 } 26604 26605 func (s *Index_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 26606 return antlr.TreesStringTree(s, ruleNames, recog) 26607 } 26608 26609 func (s *Index_nameContext) EnterRule(listener antlr.ParseTreeListener) { 26610 if listenerT, ok := listener.(ParserListener); ok { 26611 listenerT.EnterIndex_name(s) 26612 } 26613 } 26614 26615 func (s *Index_nameContext) ExitRule(listener antlr.ParseTreeListener) { 26616 if listenerT, ok := listener.(ParserListener); ok { 26617 listenerT.ExitIndex_name(s) 26618 } 26619 } 26620 26621 func (s *Index_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 26622 switch t := visitor.(type) { 26623 case ParserVisitor: 26624 return t.VisitIndex_name(s) 26625 26626 default: 26627 return t.VisitChildren(s) 26628 } 26629 } 26630 26631 func (p *Parser) Index_name() (localctx IIndex_nameContext) { 26632 this := p 26633 _ = this 26634 26635 localctx = NewIndex_nameContext(p, p.GetParserRuleContext(), p.GetState()) 26636 p.EnterRule(localctx, 194, ParserRULE_index_name) 26637 26638 defer func() { 26639 p.ExitRule() 26640 }() 26641 26642 defer func() { 26643 if err := recover(); err != nil { 26644 if v, ok := err.(antlr.RecognitionException); ok { 26645 localctx.SetException(v) 26646 p.GetErrorHandler().ReportError(p, v) 26647 p.GetErrorHandler().Recover(p, v) 26648 } else { 26649 panic(err) 26650 } 26651 } 26652 }() 26653 26654 p.EnterOuterAlt(localctx, 1) 26655 { 26656 p.SetState(2043) 26657 p.Any_name() 26658 } 26659 26660 return localctx 26661 } 26662 26663 // ITrigger_nameContext is an interface to support dynamic dispatch. 26664 type ITrigger_nameContext interface { 26665 antlr.ParserRuleContext 26666 26667 // GetParser returns the parser. 26668 GetParser() antlr.Parser 26669 26670 // IsTrigger_nameContext differentiates from other interfaces. 26671 IsTrigger_nameContext() 26672 } 26673 26674 type Trigger_nameContext struct { 26675 *antlr.BaseParserRuleContext 26676 parser antlr.Parser 26677 } 26678 26679 func NewEmptyTrigger_nameContext() *Trigger_nameContext { 26680 var p = new(Trigger_nameContext) 26681 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 26682 p.RuleIndex = ParserRULE_trigger_name 26683 return p 26684 } 26685 26686 func (*Trigger_nameContext) IsTrigger_nameContext() {} 26687 26688 func NewTrigger_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Trigger_nameContext { 26689 var p = new(Trigger_nameContext) 26690 26691 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 26692 26693 p.parser = parser 26694 p.RuleIndex = ParserRULE_trigger_name 26695 26696 return p 26697 } 26698 26699 func (s *Trigger_nameContext) GetParser() antlr.Parser { return s.parser } 26700 26701 func (s *Trigger_nameContext) Any_name() IAny_nameContext { 26702 var t antlr.RuleContext 26703 for _, ctx := range s.GetChildren() { 26704 if _, ok := ctx.(IAny_nameContext); ok { 26705 t = ctx.(antlr.RuleContext) 26706 break 26707 } 26708 } 26709 26710 if t == nil { 26711 return nil 26712 } 26713 26714 return t.(IAny_nameContext) 26715 } 26716 26717 func (s *Trigger_nameContext) GetRuleContext() antlr.RuleContext { 26718 return s 26719 } 26720 26721 func (s *Trigger_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 26722 return antlr.TreesStringTree(s, ruleNames, recog) 26723 } 26724 26725 func (s *Trigger_nameContext) EnterRule(listener antlr.ParseTreeListener) { 26726 if listenerT, ok := listener.(ParserListener); ok { 26727 listenerT.EnterTrigger_name(s) 26728 } 26729 } 26730 26731 func (s *Trigger_nameContext) ExitRule(listener antlr.ParseTreeListener) { 26732 if listenerT, ok := listener.(ParserListener); ok { 26733 listenerT.ExitTrigger_name(s) 26734 } 26735 } 26736 26737 func (s *Trigger_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 26738 switch t := visitor.(type) { 26739 case ParserVisitor: 26740 return t.VisitTrigger_name(s) 26741 26742 default: 26743 return t.VisitChildren(s) 26744 } 26745 } 26746 26747 func (p *Parser) Trigger_name() (localctx ITrigger_nameContext) { 26748 this := p 26749 _ = this 26750 26751 localctx = NewTrigger_nameContext(p, p.GetParserRuleContext(), p.GetState()) 26752 p.EnterRule(localctx, 196, ParserRULE_trigger_name) 26753 26754 defer func() { 26755 p.ExitRule() 26756 }() 26757 26758 defer func() { 26759 if err := recover(); err != nil { 26760 if v, ok := err.(antlr.RecognitionException); ok { 26761 localctx.SetException(v) 26762 p.GetErrorHandler().ReportError(p, v) 26763 p.GetErrorHandler().Recover(p, v) 26764 } else { 26765 panic(err) 26766 } 26767 } 26768 }() 26769 26770 p.EnterOuterAlt(localctx, 1) 26771 { 26772 p.SetState(2045) 26773 p.Any_name() 26774 } 26775 26776 return localctx 26777 } 26778 26779 // IView_nameContext is an interface to support dynamic dispatch. 26780 type IView_nameContext interface { 26781 antlr.ParserRuleContext 26782 26783 // GetParser returns the parser. 26784 GetParser() antlr.Parser 26785 26786 // IsView_nameContext differentiates from other interfaces. 26787 IsView_nameContext() 26788 } 26789 26790 type View_nameContext struct { 26791 *antlr.BaseParserRuleContext 26792 parser antlr.Parser 26793 } 26794 26795 func NewEmptyView_nameContext() *View_nameContext { 26796 var p = new(View_nameContext) 26797 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 26798 p.RuleIndex = ParserRULE_view_name 26799 return p 26800 } 26801 26802 func (*View_nameContext) IsView_nameContext() {} 26803 26804 func NewView_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *View_nameContext { 26805 var p = new(View_nameContext) 26806 26807 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 26808 26809 p.parser = parser 26810 p.RuleIndex = ParserRULE_view_name 26811 26812 return p 26813 } 26814 26815 func (s *View_nameContext) GetParser() antlr.Parser { return s.parser } 26816 26817 func (s *View_nameContext) Any_name() IAny_nameContext { 26818 var t antlr.RuleContext 26819 for _, ctx := range s.GetChildren() { 26820 if _, ok := ctx.(IAny_nameContext); ok { 26821 t = ctx.(antlr.RuleContext) 26822 break 26823 } 26824 } 26825 26826 if t == nil { 26827 return nil 26828 } 26829 26830 return t.(IAny_nameContext) 26831 } 26832 26833 func (s *View_nameContext) GetRuleContext() antlr.RuleContext { 26834 return s 26835 } 26836 26837 func (s *View_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 26838 return antlr.TreesStringTree(s, ruleNames, recog) 26839 } 26840 26841 func (s *View_nameContext) EnterRule(listener antlr.ParseTreeListener) { 26842 if listenerT, ok := listener.(ParserListener); ok { 26843 listenerT.EnterView_name(s) 26844 } 26845 } 26846 26847 func (s *View_nameContext) ExitRule(listener antlr.ParseTreeListener) { 26848 if listenerT, ok := listener.(ParserListener); ok { 26849 listenerT.ExitView_name(s) 26850 } 26851 } 26852 26853 func (s *View_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 26854 switch t := visitor.(type) { 26855 case ParserVisitor: 26856 return t.VisitView_name(s) 26857 26858 default: 26859 return t.VisitChildren(s) 26860 } 26861 } 26862 26863 func (p *Parser) View_name() (localctx IView_nameContext) { 26864 this := p 26865 _ = this 26866 26867 localctx = NewView_nameContext(p, p.GetParserRuleContext(), p.GetState()) 26868 p.EnterRule(localctx, 198, ParserRULE_view_name) 26869 26870 defer func() { 26871 p.ExitRule() 26872 }() 26873 26874 defer func() { 26875 if err := recover(); err != nil { 26876 if v, ok := err.(antlr.RecognitionException); ok { 26877 localctx.SetException(v) 26878 p.GetErrorHandler().ReportError(p, v) 26879 p.GetErrorHandler().Recover(p, v) 26880 } else { 26881 panic(err) 26882 } 26883 } 26884 }() 26885 26886 p.EnterOuterAlt(localctx, 1) 26887 { 26888 p.SetState(2047) 26889 p.Any_name() 26890 } 26891 26892 return localctx 26893 } 26894 26895 // IModule_nameContext is an interface to support dynamic dispatch. 26896 type IModule_nameContext interface { 26897 antlr.ParserRuleContext 26898 26899 // GetParser returns the parser. 26900 GetParser() antlr.Parser 26901 26902 // IsModule_nameContext differentiates from other interfaces. 26903 IsModule_nameContext() 26904 } 26905 26906 type Module_nameContext struct { 26907 *antlr.BaseParserRuleContext 26908 parser antlr.Parser 26909 } 26910 26911 func NewEmptyModule_nameContext() *Module_nameContext { 26912 var p = new(Module_nameContext) 26913 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 26914 p.RuleIndex = ParserRULE_module_name 26915 return p 26916 } 26917 26918 func (*Module_nameContext) IsModule_nameContext() {} 26919 26920 func NewModule_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Module_nameContext { 26921 var p = new(Module_nameContext) 26922 26923 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 26924 26925 p.parser = parser 26926 p.RuleIndex = ParserRULE_module_name 26927 26928 return p 26929 } 26930 26931 func (s *Module_nameContext) GetParser() antlr.Parser { return s.parser } 26932 26933 func (s *Module_nameContext) Any_name() IAny_nameContext { 26934 var t antlr.RuleContext 26935 for _, ctx := range s.GetChildren() { 26936 if _, ok := ctx.(IAny_nameContext); ok { 26937 t = ctx.(antlr.RuleContext) 26938 break 26939 } 26940 } 26941 26942 if t == nil { 26943 return nil 26944 } 26945 26946 return t.(IAny_nameContext) 26947 } 26948 26949 func (s *Module_nameContext) GetRuleContext() antlr.RuleContext { 26950 return s 26951 } 26952 26953 func (s *Module_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 26954 return antlr.TreesStringTree(s, ruleNames, recog) 26955 } 26956 26957 func (s *Module_nameContext) EnterRule(listener antlr.ParseTreeListener) { 26958 if listenerT, ok := listener.(ParserListener); ok { 26959 listenerT.EnterModule_name(s) 26960 } 26961 } 26962 26963 func (s *Module_nameContext) ExitRule(listener antlr.ParseTreeListener) { 26964 if listenerT, ok := listener.(ParserListener); ok { 26965 listenerT.ExitModule_name(s) 26966 } 26967 } 26968 26969 func (s *Module_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 26970 switch t := visitor.(type) { 26971 case ParserVisitor: 26972 return t.VisitModule_name(s) 26973 26974 default: 26975 return t.VisitChildren(s) 26976 } 26977 } 26978 26979 func (p *Parser) Module_name() (localctx IModule_nameContext) { 26980 this := p 26981 _ = this 26982 26983 localctx = NewModule_nameContext(p, p.GetParserRuleContext(), p.GetState()) 26984 p.EnterRule(localctx, 200, ParserRULE_module_name) 26985 26986 defer func() { 26987 p.ExitRule() 26988 }() 26989 26990 defer func() { 26991 if err := recover(); err != nil { 26992 if v, ok := err.(antlr.RecognitionException); ok { 26993 localctx.SetException(v) 26994 p.GetErrorHandler().ReportError(p, v) 26995 p.GetErrorHandler().Recover(p, v) 26996 } else { 26997 panic(err) 26998 } 26999 } 27000 }() 27001 27002 p.EnterOuterAlt(localctx, 1) 27003 { 27004 p.SetState(2049) 27005 p.Any_name() 27006 } 27007 27008 return localctx 27009 } 27010 27011 // IPragma_nameContext is an interface to support dynamic dispatch. 27012 type IPragma_nameContext interface { 27013 antlr.ParserRuleContext 27014 27015 // GetParser returns the parser. 27016 GetParser() antlr.Parser 27017 27018 // IsPragma_nameContext differentiates from other interfaces. 27019 IsPragma_nameContext() 27020 } 27021 27022 type Pragma_nameContext struct { 27023 *antlr.BaseParserRuleContext 27024 parser antlr.Parser 27025 } 27026 27027 func NewEmptyPragma_nameContext() *Pragma_nameContext { 27028 var p = new(Pragma_nameContext) 27029 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 27030 p.RuleIndex = ParserRULE_pragma_name 27031 return p 27032 } 27033 27034 func (*Pragma_nameContext) IsPragma_nameContext() {} 27035 27036 func NewPragma_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pragma_nameContext { 27037 var p = new(Pragma_nameContext) 27038 27039 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 27040 27041 p.parser = parser 27042 p.RuleIndex = ParserRULE_pragma_name 27043 27044 return p 27045 } 27046 27047 func (s *Pragma_nameContext) GetParser() antlr.Parser { return s.parser } 27048 27049 func (s *Pragma_nameContext) Any_name() IAny_nameContext { 27050 var t antlr.RuleContext 27051 for _, ctx := range s.GetChildren() { 27052 if _, ok := ctx.(IAny_nameContext); ok { 27053 t = ctx.(antlr.RuleContext) 27054 break 27055 } 27056 } 27057 27058 if t == nil { 27059 return nil 27060 } 27061 27062 return t.(IAny_nameContext) 27063 } 27064 27065 func (s *Pragma_nameContext) GetRuleContext() antlr.RuleContext { 27066 return s 27067 } 27068 27069 func (s *Pragma_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 27070 return antlr.TreesStringTree(s, ruleNames, recog) 27071 } 27072 27073 func (s *Pragma_nameContext) EnterRule(listener antlr.ParseTreeListener) { 27074 if listenerT, ok := listener.(ParserListener); ok { 27075 listenerT.EnterPragma_name(s) 27076 } 27077 } 27078 27079 func (s *Pragma_nameContext) ExitRule(listener antlr.ParseTreeListener) { 27080 if listenerT, ok := listener.(ParserListener); ok { 27081 listenerT.ExitPragma_name(s) 27082 } 27083 } 27084 27085 func (s *Pragma_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 27086 switch t := visitor.(type) { 27087 case ParserVisitor: 27088 return t.VisitPragma_name(s) 27089 27090 default: 27091 return t.VisitChildren(s) 27092 } 27093 } 27094 27095 func (p *Parser) Pragma_name() (localctx IPragma_nameContext) { 27096 this := p 27097 _ = this 27098 27099 localctx = NewPragma_nameContext(p, p.GetParserRuleContext(), p.GetState()) 27100 p.EnterRule(localctx, 202, ParserRULE_pragma_name) 27101 27102 defer func() { 27103 p.ExitRule() 27104 }() 27105 27106 defer func() { 27107 if err := recover(); err != nil { 27108 if v, ok := err.(antlr.RecognitionException); ok { 27109 localctx.SetException(v) 27110 p.GetErrorHandler().ReportError(p, v) 27111 p.GetErrorHandler().Recover(p, v) 27112 } else { 27113 panic(err) 27114 } 27115 } 27116 }() 27117 27118 p.EnterOuterAlt(localctx, 1) 27119 { 27120 p.SetState(2051) 27121 p.Any_name() 27122 } 27123 27124 return localctx 27125 } 27126 27127 // ISavepoint_nameContext is an interface to support dynamic dispatch. 27128 type ISavepoint_nameContext interface { 27129 antlr.ParserRuleContext 27130 27131 // GetParser returns the parser. 27132 GetParser() antlr.Parser 27133 27134 // IsSavepoint_nameContext differentiates from other interfaces. 27135 IsSavepoint_nameContext() 27136 } 27137 27138 type Savepoint_nameContext struct { 27139 *antlr.BaseParserRuleContext 27140 parser antlr.Parser 27141 } 27142 27143 func NewEmptySavepoint_nameContext() *Savepoint_nameContext { 27144 var p = new(Savepoint_nameContext) 27145 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 27146 p.RuleIndex = ParserRULE_savepoint_name 27147 return p 27148 } 27149 27150 func (*Savepoint_nameContext) IsSavepoint_nameContext() {} 27151 27152 func NewSavepoint_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Savepoint_nameContext { 27153 var p = new(Savepoint_nameContext) 27154 27155 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 27156 27157 p.parser = parser 27158 p.RuleIndex = ParserRULE_savepoint_name 27159 27160 return p 27161 } 27162 27163 func (s *Savepoint_nameContext) GetParser() antlr.Parser { return s.parser } 27164 27165 func (s *Savepoint_nameContext) Any_name() IAny_nameContext { 27166 var t antlr.RuleContext 27167 for _, ctx := range s.GetChildren() { 27168 if _, ok := ctx.(IAny_nameContext); ok { 27169 t = ctx.(antlr.RuleContext) 27170 break 27171 } 27172 } 27173 27174 if t == nil { 27175 return nil 27176 } 27177 27178 return t.(IAny_nameContext) 27179 } 27180 27181 func (s *Savepoint_nameContext) GetRuleContext() antlr.RuleContext { 27182 return s 27183 } 27184 27185 func (s *Savepoint_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 27186 return antlr.TreesStringTree(s, ruleNames, recog) 27187 } 27188 27189 func (s *Savepoint_nameContext) EnterRule(listener antlr.ParseTreeListener) { 27190 if listenerT, ok := listener.(ParserListener); ok { 27191 listenerT.EnterSavepoint_name(s) 27192 } 27193 } 27194 27195 func (s *Savepoint_nameContext) ExitRule(listener antlr.ParseTreeListener) { 27196 if listenerT, ok := listener.(ParserListener); ok { 27197 listenerT.ExitSavepoint_name(s) 27198 } 27199 } 27200 27201 func (s *Savepoint_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 27202 switch t := visitor.(type) { 27203 case ParserVisitor: 27204 return t.VisitSavepoint_name(s) 27205 27206 default: 27207 return t.VisitChildren(s) 27208 } 27209 } 27210 27211 func (p *Parser) Savepoint_name() (localctx ISavepoint_nameContext) { 27212 this := p 27213 _ = this 27214 27215 localctx = NewSavepoint_nameContext(p, p.GetParserRuleContext(), p.GetState()) 27216 p.EnterRule(localctx, 204, ParserRULE_savepoint_name) 27217 27218 defer func() { 27219 p.ExitRule() 27220 }() 27221 27222 defer func() { 27223 if err := recover(); err != nil { 27224 if v, ok := err.(antlr.RecognitionException); ok { 27225 localctx.SetException(v) 27226 p.GetErrorHandler().ReportError(p, v) 27227 p.GetErrorHandler().Recover(p, v) 27228 } else { 27229 panic(err) 27230 } 27231 } 27232 }() 27233 27234 p.EnterOuterAlt(localctx, 1) 27235 { 27236 p.SetState(2053) 27237 p.Any_name() 27238 } 27239 27240 return localctx 27241 } 27242 27243 // ITable_aliasContext is an interface to support dynamic dispatch. 27244 type ITable_aliasContext interface { 27245 antlr.ParserRuleContext 27246 27247 // GetParser returns the parser. 27248 GetParser() antlr.Parser 27249 27250 // IsTable_aliasContext differentiates from other interfaces. 27251 IsTable_aliasContext() 27252 } 27253 27254 type Table_aliasContext struct { 27255 *antlr.BaseParserRuleContext 27256 parser antlr.Parser 27257 } 27258 27259 func NewEmptyTable_aliasContext() *Table_aliasContext { 27260 var p = new(Table_aliasContext) 27261 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 27262 p.RuleIndex = ParserRULE_table_alias 27263 return p 27264 } 27265 27266 func (*Table_aliasContext) IsTable_aliasContext() {} 27267 27268 func NewTable_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_aliasContext { 27269 var p = new(Table_aliasContext) 27270 27271 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 27272 27273 p.parser = parser 27274 p.RuleIndex = ParserRULE_table_alias 27275 27276 return p 27277 } 27278 27279 func (s *Table_aliasContext) GetParser() antlr.Parser { return s.parser } 27280 27281 func (s *Table_aliasContext) Any_name() IAny_nameContext { 27282 var t antlr.RuleContext 27283 for _, ctx := range s.GetChildren() { 27284 if _, ok := ctx.(IAny_nameContext); ok { 27285 t = ctx.(antlr.RuleContext) 27286 break 27287 } 27288 } 27289 27290 if t == nil { 27291 return nil 27292 } 27293 27294 return t.(IAny_nameContext) 27295 } 27296 27297 func (s *Table_aliasContext) GetRuleContext() antlr.RuleContext { 27298 return s 27299 } 27300 27301 func (s *Table_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 27302 return antlr.TreesStringTree(s, ruleNames, recog) 27303 } 27304 27305 func (s *Table_aliasContext) EnterRule(listener antlr.ParseTreeListener) { 27306 if listenerT, ok := listener.(ParserListener); ok { 27307 listenerT.EnterTable_alias(s) 27308 } 27309 } 27310 27311 func (s *Table_aliasContext) ExitRule(listener antlr.ParseTreeListener) { 27312 if listenerT, ok := listener.(ParserListener); ok { 27313 listenerT.ExitTable_alias(s) 27314 } 27315 } 27316 27317 func (s *Table_aliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 27318 switch t := visitor.(type) { 27319 case ParserVisitor: 27320 return t.VisitTable_alias(s) 27321 27322 default: 27323 return t.VisitChildren(s) 27324 } 27325 } 27326 27327 func (p *Parser) Table_alias() (localctx ITable_aliasContext) { 27328 this := p 27329 _ = this 27330 27331 localctx = NewTable_aliasContext(p, p.GetParserRuleContext(), p.GetState()) 27332 p.EnterRule(localctx, 206, ParserRULE_table_alias) 27333 27334 defer func() { 27335 p.ExitRule() 27336 }() 27337 27338 defer func() { 27339 if err := recover(); err != nil { 27340 if v, ok := err.(antlr.RecognitionException); ok { 27341 localctx.SetException(v) 27342 p.GetErrorHandler().ReportError(p, v) 27343 p.GetErrorHandler().Recover(p, v) 27344 } else { 27345 panic(err) 27346 } 27347 } 27348 }() 27349 27350 p.EnterOuterAlt(localctx, 1) 27351 { 27352 p.SetState(2055) 27353 p.Any_name() 27354 } 27355 27356 return localctx 27357 } 27358 27359 // ITransaction_nameContext is an interface to support dynamic dispatch. 27360 type ITransaction_nameContext interface { 27361 antlr.ParserRuleContext 27362 27363 // GetParser returns the parser. 27364 GetParser() antlr.Parser 27365 27366 // IsTransaction_nameContext differentiates from other interfaces. 27367 IsTransaction_nameContext() 27368 } 27369 27370 type Transaction_nameContext struct { 27371 *antlr.BaseParserRuleContext 27372 parser antlr.Parser 27373 } 27374 27375 func NewEmptyTransaction_nameContext() *Transaction_nameContext { 27376 var p = new(Transaction_nameContext) 27377 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 27378 p.RuleIndex = ParserRULE_transaction_name 27379 return p 27380 } 27381 27382 func (*Transaction_nameContext) IsTransaction_nameContext() {} 27383 27384 func NewTransaction_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transaction_nameContext { 27385 var p = new(Transaction_nameContext) 27386 27387 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 27388 27389 p.parser = parser 27390 p.RuleIndex = ParserRULE_transaction_name 27391 27392 return p 27393 } 27394 27395 func (s *Transaction_nameContext) GetParser() antlr.Parser { return s.parser } 27396 27397 func (s *Transaction_nameContext) Any_name() IAny_nameContext { 27398 var t antlr.RuleContext 27399 for _, ctx := range s.GetChildren() { 27400 if _, ok := ctx.(IAny_nameContext); ok { 27401 t = ctx.(antlr.RuleContext) 27402 break 27403 } 27404 } 27405 27406 if t == nil { 27407 return nil 27408 } 27409 27410 return t.(IAny_nameContext) 27411 } 27412 27413 func (s *Transaction_nameContext) GetRuleContext() antlr.RuleContext { 27414 return s 27415 } 27416 27417 func (s *Transaction_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 27418 return antlr.TreesStringTree(s, ruleNames, recog) 27419 } 27420 27421 func (s *Transaction_nameContext) EnterRule(listener antlr.ParseTreeListener) { 27422 if listenerT, ok := listener.(ParserListener); ok { 27423 listenerT.EnterTransaction_name(s) 27424 } 27425 } 27426 27427 func (s *Transaction_nameContext) ExitRule(listener antlr.ParseTreeListener) { 27428 if listenerT, ok := listener.(ParserListener); ok { 27429 listenerT.ExitTransaction_name(s) 27430 } 27431 } 27432 27433 func (s *Transaction_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 27434 switch t := visitor.(type) { 27435 case ParserVisitor: 27436 return t.VisitTransaction_name(s) 27437 27438 default: 27439 return t.VisitChildren(s) 27440 } 27441 } 27442 27443 func (p *Parser) Transaction_name() (localctx ITransaction_nameContext) { 27444 this := p 27445 _ = this 27446 27447 localctx = NewTransaction_nameContext(p, p.GetParserRuleContext(), p.GetState()) 27448 p.EnterRule(localctx, 208, ParserRULE_transaction_name) 27449 27450 defer func() { 27451 p.ExitRule() 27452 }() 27453 27454 defer func() { 27455 if err := recover(); err != nil { 27456 if v, ok := err.(antlr.RecognitionException); ok { 27457 localctx.SetException(v) 27458 p.GetErrorHandler().ReportError(p, v) 27459 p.GetErrorHandler().Recover(p, v) 27460 } else { 27461 panic(err) 27462 } 27463 } 27464 }() 27465 27466 p.EnterOuterAlt(localctx, 1) 27467 { 27468 p.SetState(2057) 27469 p.Any_name() 27470 } 27471 27472 return localctx 27473 } 27474 27475 // IWindow_nameContext is an interface to support dynamic dispatch. 27476 type IWindow_nameContext interface { 27477 antlr.ParserRuleContext 27478 27479 // GetParser returns the parser. 27480 GetParser() antlr.Parser 27481 27482 // IsWindow_nameContext differentiates from other interfaces. 27483 IsWindow_nameContext() 27484 } 27485 27486 type Window_nameContext struct { 27487 *antlr.BaseParserRuleContext 27488 parser antlr.Parser 27489 } 27490 27491 func NewEmptyWindow_nameContext() *Window_nameContext { 27492 var p = new(Window_nameContext) 27493 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 27494 p.RuleIndex = ParserRULE_window_name 27495 return p 27496 } 27497 27498 func (*Window_nameContext) IsWindow_nameContext() {} 27499 27500 func NewWindow_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_nameContext { 27501 var p = new(Window_nameContext) 27502 27503 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 27504 27505 p.parser = parser 27506 p.RuleIndex = ParserRULE_window_name 27507 27508 return p 27509 } 27510 27511 func (s *Window_nameContext) GetParser() antlr.Parser { return s.parser } 27512 27513 func (s *Window_nameContext) Any_name() IAny_nameContext { 27514 var t antlr.RuleContext 27515 for _, ctx := range s.GetChildren() { 27516 if _, ok := ctx.(IAny_nameContext); ok { 27517 t = ctx.(antlr.RuleContext) 27518 break 27519 } 27520 } 27521 27522 if t == nil { 27523 return nil 27524 } 27525 27526 return t.(IAny_nameContext) 27527 } 27528 27529 func (s *Window_nameContext) GetRuleContext() antlr.RuleContext { 27530 return s 27531 } 27532 27533 func (s *Window_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 27534 return antlr.TreesStringTree(s, ruleNames, recog) 27535 } 27536 27537 func (s *Window_nameContext) EnterRule(listener antlr.ParseTreeListener) { 27538 if listenerT, ok := listener.(ParserListener); ok { 27539 listenerT.EnterWindow_name(s) 27540 } 27541 } 27542 27543 func (s *Window_nameContext) ExitRule(listener antlr.ParseTreeListener) { 27544 if listenerT, ok := listener.(ParserListener); ok { 27545 listenerT.ExitWindow_name(s) 27546 } 27547 } 27548 27549 func (s *Window_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 27550 switch t := visitor.(type) { 27551 case ParserVisitor: 27552 return t.VisitWindow_name(s) 27553 27554 default: 27555 return t.VisitChildren(s) 27556 } 27557 } 27558 27559 func (p *Parser) Window_name() (localctx IWindow_nameContext) { 27560 this := p 27561 _ = this 27562 27563 localctx = NewWindow_nameContext(p, p.GetParserRuleContext(), p.GetState()) 27564 p.EnterRule(localctx, 210, ParserRULE_window_name) 27565 27566 defer func() { 27567 p.ExitRule() 27568 }() 27569 27570 defer func() { 27571 if err := recover(); err != nil { 27572 if v, ok := err.(antlr.RecognitionException); ok { 27573 localctx.SetException(v) 27574 p.GetErrorHandler().ReportError(p, v) 27575 p.GetErrorHandler().Recover(p, v) 27576 } else { 27577 panic(err) 27578 } 27579 } 27580 }() 27581 27582 p.EnterOuterAlt(localctx, 1) 27583 { 27584 p.SetState(2059) 27585 p.Any_name() 27586 } 27587 27588 return localctx 27589 } 27590 27591 // IAliasContext is an interface to support dynamic dispatch. 27592 type IAliasContext interface { 27593 antlr.ParserRuleContext 27594 27595 // GetParser returns the parser. 27596 GetParser() antlr.Parser 27597 27598 // IsAliasContext differentiates from other interfaces. 27599 IsAliasContext() 27600 } 27601 27602 type AliasContext struct { 27603 *antlr.BaseParserRuleContext 27604 parser antlr.Parser 27605 } 27606 27607 func NewEmptyAliasContext() *AliasContext { 27608 var p = new(AliasContext) 27609 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 27610 p.RuleIndex = ParserRULE_alias 27611 return p 27612 } 27613 27614 func (*AliasContext) IsAliasContext() {} 27615 27616 func NewAliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AliasContext { 27617 var p = new(AliasContext) 27618 27619 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 27620 27621 p.parser = parser 27622 p.RuleIndex = ParserRULE_alias 27623 27624 return p 27625 } 27626 27627 func (s *AliasContext) GetParser() antlr.Parser { return s.parser } 27628 27629 func (s *AliasContext) Any_name() IAny_nameContext { 27630 var t antlr.RuleContext 27631 for _, ctx := range s.GetChildren() { 27632 if _, ok := ctx.(IAny_nameContext); ok { 27633 t = ctx.(antlr.RuleContext) 27634 break 27635 } 27636 } 27637 27638 if t == nil { 27639 return nil 27640 } 27641 27642 return t.(IAny_nameContext) 27643 } 27644 27645 func (s *AliasContext) GetRuleContext() antlr.RuleContext { 27646 return s 27647 } 27648 27649 func (s *AliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 27650 return antlr.TreesStringTree(s, ruleNames, recog) 27651 } 27652 27653 func (s *AliasContext) EnterRule(listener antlr.ParseTreeListener) { 27654 if listenerT, ok := listener.(ParserListener); ok { 27655 listenerT.EnterAlias(s) 27656 } 27657 } 27658 27659 func (s *AliasContext) ExitRule(listener antlr.ParseTreeListener) { 27660 if listenerT, ok := listener.(ParserListener); ok { 27661 listenerT.ExitAlias(s) 27662 } 27663 } 27664 27665 func (s *AliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 27666 switch t := visitor.(type) { 27667 case ParserVisitor: 27668 return t.VisitAlias(s) 27669 27670 default: 27671 return t.VisitChildren(s) 27672 } 27673 } 27674 27675 func (p *Parser) Alias() (localctx IAliasContext) { 27676 this := p 27677 _ = this 27678 27679 localctx = NewAliasContext(p, p.GetParserRuleContext(), p.GetState()) 27680 p.EnterRule(localctx, 212, ParserRULE_alias) 27681 27682 defer func() { 27683 p.ExitRule() 27684 }() 27685 27686 defer func() { 27687 if err := recover(); err != nil { 27688 if v, ok := err.(antlr.RecognitionException); ok { 27689 localctx.SetException(v) 27690 p.GetErrorHandler().ReportError(p, v) 27691 p.GetErrorHandler().Recover(p, v) 27692 } else { 27693 panic(err) 27694 } 27695 } 27696 }() 27697 27698 p.EnterOuterAlt(localctx, 1) 27699 { 27700 p.SetState(2061) 27701 p.Any_name() 27702 } 27703 27704 return localctx 27705 } 27706 27707 // IFilenameContext is an interface to support dynamic dispatch. 27708 type IFilenameContext interface { 27709 antlr.ParserRuleContext 27710 27711 // GetParser returns the parser. 27712 GetParser() antlr.Parser 27713 27714 // IsFilenameContext differentiates from other interfaces. 27715 IsFilenameContext() 27716 } 27717 27718 type FilenameContext struct { 27719 *antlr.BaseParserRuleContext 27720 parser antlr.Parser 27721 } 27722 27723 func NewEmptyFilenameContext() *FilenameContext { 27724 var p = new(FilenameContext) 27725 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 27726 p.RuleIndex = ParserRULE_filename 27727 return p 27728 } 27729 27730 func (*FilenameContext) IsFilenameContext() {} 27731 27732 func NewFilenameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FilenameContext { 27733 var p = new(FilenameContext) 27734 27735 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 27736 27737 p.parser = parser 27738 p.RuleIndex = ParserRULE_filename 27739 27740 return p 27741 } 27742 27743 func (s *FilenameContext) GetParser() antlr.Parser { return s.parser } 27744 27745 func (s *FilenameContext) Any_name() IAny_nameContext { 27746 var t antlr.RuleContext 27747 for _, ctx := range s.GetChildren() { 27748 if _, ok := ctx.(IAny_nameContext); ok { 27749 t = ctx.(antlr.RuleContext) 27750 break 27751 } 27752 } 27753 27754 if t == nil { 27755 return nil 27756 } 27757 27758 return t.(IAny_nameContext) 27759 } 27760 27761 func (s *FilenameContext) GetRuleContext() antlr.RuleContext { 27762 return s 27763 } 27764 27765 func (s *FilenameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 27766 return antlr.TreesStringTree(s, ruleNames, recog) 27767 } 27768 27769 func (s *FilenameContext) EnterRule(listener antlr.ParseTreeListener) { 27770 if listenerT, ok := listener.(ParserListener); ok { 27771 listenerT.EnterFilename(s) 27772 } 27773 } 27774 27775 func (s *FilenameContext) ExitRule(listener antlr.ParseTreeListener) { 27776 if listenerT, ok := listener.(ParserListener); ok { 27777 listenerT.ExitFilename(s) 27778 } 27779 } 27780 27781 func (s *FilenameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 27782 switch t := visitor.(type) { 27783 case ParserVisitor: 27784 return t.VisitFilename(s) 27785 27786 default: 27787 return t.VisitChildren(s) 27788 } 27789 } 27790 27791 func (p *Parser) Filename() (localctx IFilenameContext) { 27792 this := p 27793 _ = this 27794 27795 localctx = NewFilenameContext(p, p.GetParserRuleContext(), p.GetState()) 27796 p.EnterRule(localctx, 214, ParserRULE_filename) 27797 27798 defer func() { 27799 p.ExitRule() 27800 }() 27801 27802 defer func() { 27803 if err := recover(); err != nil { 27804 if v, ok := err.(antlr.RecognitionException); ok { 27805 localctx.SetException(v) 27806 p.GetErrorHandler().ReportError(p, v) 27807 p.GetErrorHandler().Recover(p, v) 27808 } else { 27809 panic(err) 27810 } 27811 } 27812 }() 27813 27814 p.EnterOuterAlt(localctx, 1) 27815 { 27816 p.SetState(2063) 27817 p.Any_name() 27818 } 27819 27820 return localctx 27821 } 27822 27823 // IBase_window_nameContext is an interface to support dynamic dispatch. 27824 type IBase_window_nameContext interface { 27825 antlr.ParserRuleContext 27826 27827 // GetParser returns the parser. 27828 GetParser() antlr.Parser 27829 27830 // IsBase_window_nameContext differentiates from other interfaces. 27831 IsBase_window_nameContext() 27832 } 27833 27834 type Base_window_nameContext struct { 27835 *antlr.BaseParserRuleContext 27836 parser antlr.Parser 27837 } 27838 27839 func NewEmptyBase_window_nameContext() *Base_window_nameContext { 27840 var p = new(Base_window_nameContext) 27841 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 27842 p.RuleIndex = ParserRULE_base_window_name 27843 return p 27844 } 27845 27846 func (*Base_window_nameContext) IsBase_window_nameContext() {} 27847 27848 func NewBase_window_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Base_window_nameContext { 27849 var p = new(Base_window_nameContext) 27850 27851 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 27852 27853 p.parser = parser 27854 p.RuleIndex = ParserRULE_base_window_name 27855 27856 return p 27857 } 27858 27859 func (s *Base_window_nameContext) GetParser() antlr.Parser { return s.parser } 27860 27861 func (s *Base_window_nameContext) Any_name() IAny_nameContext { 27862 var t antlr.RuleContext 27863 for _, ctx := range s.GetChildren() { 27864 if _, ok := ctx.(IAny_nameContext); ok { 27865 t = ctx.(antlr.RuleContext) 27866 break 27867 } 27868 } 27869 27870 if t == nil { 27871 return nil 27872 } 27873 27874 return t.(IAny_nameContext) 27875 } 27876 27877 func (s *Base_window_nameContext) GetRuleContext() antlr.RuleContext { 27878 return s 27879 } 27880 27881 func (s *Base_window_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 27882 return antlr.TreesStringTree(s, ruleNames, recog) 27883 } 27884 27885 func (s *Base_window_nameContext) EnterRule(listener antlr.ParseTreeListener) { 27886 if listenerT, ok := listener.(ParserListener); ok { 27887 listenerT.EnterBase_window_name(s) 27888 } 27889 } 27890 27891 func (s *Base_window_nameContext) ExitRule(listener antlr.ParseTreeListener) { 27892 if listenerT, ok := listener.(ParserListener); ok { 27893 listenerT.ExitBase_window_name(s) 27894 } 27895 } 27896 27897 func (s *Base_window_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 27898 switch t := visitor.(type) { 27899 case ParserVisitor: 27900 return t.VisitBase_window_name(s) 27901 27902 default: 27903 return t.VisitChildren(s) 27904 } 27905 } 27906 27907 func (p *Parser) Base_window_name() (localctx IBase_window_nameContext) { 27908 this := p 27909 _ = this 27910 27911 localctx = NewBase_window_nameContext(p, p.GetParserRuleContext(), p.GetState()) 27912 p.EnterRule(localctx, 216, ParserRULE_base_window_name) 27913 27914 defer func() { 27915 p.ExitRule() 27916 }() 27917 27918 defer func() { 27919 if err := recover(); err != nil { 27920 if v, ok := err.(antlr.RecognitionException); ok { 27921 localctx.SetException(v) 27922 p.GetErrorHandler().ReportError(p, v) 27923 p.GetErrorHandler().Recover(p, v) 27924 } else { 27925 panic(err) 27926 } 27927 } 27928 }() 27929 27930 p.EnterOuterAlt(localctx, 1) 27931 { 27932 p.SetState(2065) 27933 p.Any_name() 27934 } 27935 27936 return localctx 27937 } 27938 27939 // ISimple_funcContext is an interface to support dynamic dispatch. 27940 type ISimple_funcContext interface { 27941 antlr.ParserRuleContext 27942 27943 // GetParser returns the parser. 27944 GetParser() antlr.Parser 27945 27946 // IsSimple_funcContext differentiates from other interfaces. 27947 IsSimple_funcContext() 27948 } 27949 27950 type Simple_funcContext struct { 27951 *antlr.BaseParserRuleContext 27952 parser antlr.Parser 27953 } 27954 27955 func NewEmptySimple_funcContext() *Simple_funcContext { 27956 var p = new(Simple_funcContext) 27957 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 27958 p.RuleIndex = ParserRULE_simple_func 27959 return p 27960 } 27961 27962 func (*Simple_funcContext) IsSimple_funcContext() {} 27963 27964 func NewSimple_funcContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_funcContext { 27965 var p = new(Simple_funcContext) 27966 27967 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 27968 27969 p.parser = parser 27970 p.RuleIndex = ParserRULE_simple_func 27971 27972 return p 27973 } 27974 27975 func (s *Simple_funcContext) GetParser() antlr.Parser { return s.parser } 27976 27977 func (s *Simple_funcContext) Any_name() IAny_nameContext { 27978 var t antlr.RuleContext 27979 for _, ctx := range s.GetChildren() { 27980 if _, ok := ctx.(IAny_nameContext); ok { 27981 t = ctx.(antlr.RuleContext) 27982 break 27983 } 27984 } 27985 27986 if t == nil { 27987 return nil 27988 } 27989 27990 return t.(IAny_nameContext) 27991 } 27992 27993 func (s *Simple_funcContext) GetRuleContext() antlr.RuleContext { 27994 return s 27995 } 27996 27997 func (s *Simple_funcContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 27998 return antlr.TreesStringTree(s, ruleNames, recog) 27999 } 28000 28001 func (s *Simple_funcContext) EnterRule(listener antlr.ParseTreeListener) { 28002 if listenerT, ok := listener.(ParserListener); ok { 28003 listenerT.EnterSimple_func(s) 28004 } 28005 } 28006 28007 func (s *Simple_funcContext) ExitRule(listener antlr.ParseTreeListener) { 28008 if listenerT, ok := listener.(ParserListener); ok { 28009 listenerT.ExitSimple_func(s) 28010 } 28011 } 28012 28013 func (s *Simple_funcContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 28014 switch t := visitor.(type) { 28015 case ParserVisitor: 28016 return t.VisitSimple_func(s) 28017 28018 default: 28019 return t.VisitChildren(s) 28020 } 28021 } 28022 28023 func (p *Parser) Simple_func() (localctx ISimple_funcContext) { 28024 this := p 28025 _ = this 28026 28027 localctx = NewSimple_funcContext(p, p.GetParserRuleContext(), p.GetState()) 28028 p.EnterRule(localctx, 218, ParserRULE_simple_func) 28029 28030 defer func() { 28031 p.ExitRule() 28032 }() 28033 28034 defer func() { 28035 if err := recover(); err != nil { 28036 if v, ok := err.(antlr.RecognitionException); ok { 28037 localctx.SetException(v) 28038 p.GetErrorHandler().ReportError(p, v) 28039 p.GetErrorHandler().Recover(p, v) 28040 } else { 28041 panic(err) 28042 } 28043 } 28044 }() 28045 28046 p.EnterOuterAlt(localctx, 1) 28047 { 28048 p.SetState(2067) 28049 p.Any_name() 28050 } 28051 28052 return localctx 28053 } 28054 28055 // IAggregate_funcContext is an interface to support dynamic dispatch. 28056 type IAggregate_funcContext interface { 28057 antlr.ParserRuleContext 28058 28059 // GetParser returns the parser. 28060 GetParser() antlr.Parser 28061 28062 // IsAggregate_funcContext differentiates from other interfaces. 28063 IsAggregate_funcContext() 28064 } 28065 28066 type Aggregate_funcContext struct { 28067 *antlr.BaseParserRuleContext 28068 parser antlr.Parser 28069 } 28070 28071 func NewEmptyAggregate_funcContext() *Aggregate_funcContext { 28072 var p = new(Aggregate_funcContext) 28073 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 28074 p.RuleIndex = ParserRULE_aggregate_func 28075 return p 28076 } 28077 28078 func (*Aggregate_funcContext) IsAggregate_funcContext() {} 28079 28080 func NewAggregate_funcContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggregate_funcContext { 28081 var p = new(Aggregate_funcContext) 28082 28083 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 28084 28085 p.parser = parser 28086 p.RuleIndex = ParserRULE_aggregate_func 28087 28088 return p 28089 } 28090 28091 func (s *Aggregate_funcContext) GetParser() antlr.Parser { return s.parser } 28092 28093 func (s *Aggregate_funcContext) Any_name() IAny_nameContext { 28094 var t antlr.RuleContext 28095 for _, ctx := range s.GetChildren() { 28096 if _, ok := ctx.(IAny_nameContext); ok { 28097 t = ctx.(antlr.RuleContext) 28098 break 28099 } 28100 } 28101 28102 if t == nil { 28103 return nil 28104 } 28105 28106 return t.(IAny_nameContext) 28107 } 28108 28109 func (s *Aggregate_funcContext) GetRuleContext() antlr.RuleContext { 28110 return s 28111 } 28112 28113 func (s *Aggregate_funcContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 28114 return antlr.TreesStringTree(s, ruleNames, recog) 28115 } 28116 28117 func (s *Aggregate_funcContext) EnterRule(listener antlr.ParseTreeListener) { 28118 if listenerT, ok := listener.(ParserListener); ok { 28119 listenerT.EnterAggregate_func(s) 28120 } 28121 } 28122 28123 func (s *Aggregate_funcContext) ExitRule(listener antlr.ParseTreeListener) { 28124 if listenerT, ok := listener.(ParserListener); ok { 28125 listenerT.ExitAggregate_func(s) 28126 } 28127 } 28128 28129 func (s *Aggregate_funcContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 28130 switch t := visitor.(type) { 28131 case ParserVisitor: 28132 return t.VisitAggregate_func(s) 28133 28134 default: 28135 return t.VisitChildren(s) 28136 } 28137 } 28138 28139 func (p *Parser) Aggregate_func() (localctx IAggregate_funcContext) { 28140 this := p 28141 _ = this 28142 28143 localctx = NewAggregate_funcContext(p, p.GetParserRuleContext(), p.GetState()) 28144 p.EnterRule(localctx, 220, ParserRULE_aggregate_func) 28145 28146 defer func() { 28147 p.ExitRule() 28148 }() 28149 28150 defer func() { 28151 if err := recover(); err != nil { 28152 if v, ok := err.(antlr.RecognitionException); ok { 28153 localctx.SetException(v) 28154 p.GetErrorHandler().ReportError(p, v) 28155 p.GetErrorHandler().Recover(p, v) 28156 } else { 28157 panic(err) 28158 } 28159 } 28160 }() 28161 28162 p.EnterOuterAlt(localctx, 1) 28163 { 28164 p.SetState(2069) 28165 p.Any_name() 28166 } 28167 28168 return localctx 28169 } 28170 28171 // ITable_function_nameContext is an interface to support dynamic dispatch. 28172 type ITable_function_nameContext interface { 28173 antlr.ParserRuleContext 28174 28175 // GetParser returns the parser. 28176 GetParser() antlr.Parser 28177 28178 // IsTable_function_nameContext differentiates from other interfaces. 28179 IsTable_function_nameContext() 28180 } 28181 28182 type Table_function_nameContext struct { 28183 *antlr.BaseParserRuleContext 28184 parser antlr.Parser 28185 } 28186 28187 func NewEmptyTable_function_nameContext() *Table_function_nameContext { 28188 var p = new(Table_function_nameContext) 28189 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 28190 p.RuleIndex = ParserRULE_table_function_name 28191 return p 28192 } 28193 28194 func (*Table_function_nameContext) IsTable_function_nameContext() {} 28195 28196 func NewTable_function_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_function_nameContext { 28197 var p = new(Table_function_nameContext) 28198 28199 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 28200 28201 p.parser = parser 28202 p.RuleIndex = ParserRULE_table_function_name 28203 28204 return p 28205 } 28206 28207 func (s *Table_function_nameContext) GetParser() antlr.Parser { return s.parser } 28208 28209 func (s *Table_function_nameContext) Any_name() IAny_nameContext { 28210 var t antlr.RuleContext 28211 for _, ctx := range s.GetChildren() { 28212 if _, ok := ctx.(IAny_nameContext); ok { 28213 t = ctx.(antlr.RuleContext) 28214 break 28215 } 28216 } 28217 28218 if t == nil { 28219 return nil 28220 } 28221 28222 return t.(IAny_nameContext) 28223 } 28224 28225 func (s *Table_function_nameContext) GetRuleContext() antlr.RuleContext { 28226 return s 28227 } 28228 28229 func (s *Table_function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 28230 return antlr.TreesStringTree(s, ruleNames, recog) 28231 } 28232 28233 func (s *Table_function_nameContext) EnterRule(listener antlr.ParseTreeListener) { 28234 if listenerT, ok := listener.(ParserListener); ok { 28235 listenerT.EnterTable_function_name(s) 28236 } 28237 } 28238 28239 func (s *Table_function_nameContext) ExitRule(listener antlr.ParseTreeListener) { 28240 if listenerT, ok := listener.(ParserListener); ok { 28241 listenerT.ExitTable_function_name(s) 28242 } 28243 } 28244 28245 func (s *Table_function_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 28246 switch t := visitor.(type) { 28247 case ParserVisitor: 28248 return t.VisitTable_function_name(s) 28249 28250 default: 28251 return t.VisitChildren(s) 28252 } 28253 } 28254 28255 func (p *Parser) Table_function_name() (localctx ITable_function_nameContext) { 28256 this := p 28257 _ = this 28258 28259 localctx = NewTable_function_nameContext(p, p.GetParserRuleContext(), p.GetState()) 28260 p.EnterRule(localctx, 222, ParserRULE_table_function_name) 28261 28262 defer func() { 28263 p.ExitRule() 28264 }() 28265 28266 defer func() { 28267 if err := recover(); err != nil { 28268 if v, ok := err.(antlr.RecognitionException); ok { 28269 localctx.SetException(v) 28270 p.GetErrorHandler().ReportError(p, v) 28271 p.GetErrorHandler().Recover(p, v) 28272 } else { 28273 panic(err) 28274 } 28275 } 28276 }() 28277 28278 p.EnterOuterAlt(localctx, 1) 28279 { 28280 p.SetState(2071) 28281 p.Any_name() 28282 } 28283 28284 return localctx 28285 } 28286 28287 // IAny_nameContext is an interface to support dynamic dispatch. 28288 type IAny_nameContext interface { 28289 antlr.ParserRuleContext 28290 28291 // GetParser returns the parser. 28292 GetParser() antlr.Parser 28293 28294 // IsAny_nameContext differentiates from other interfaces. 28295 IsAny_nameContext() 28296 } 28297 28298 type Any_nameContext struct { 28299 *antlr.BaseParserRuleContext 28300 parser antlr.Parser 28301 } 28302 28303 func NewEmptyAny_nameContext() *Any_nameContext { 28304 var p = new(Any_nameContext) 28305 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1) 28306 p.RuleIndex = ParserRULE_any_name 28307 return p 28308 } 28309 28310 func (*Any_nameContext) IsAny_nameContext() {} 28311 28312 func NewAny_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Any_nameContext { 28313 var p = new(Any_nameContext) 28314 28315 p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState) 28316 28317 p.parser = parser 28318 p.RuleIndex = ParserRULE_any_name 28319 28320 return p 28321 } 28322 28323 func (s *Any_nameContext) GetParser() antlr.Parser { return s.parser } 28324 28325 func (s *Any_nameContext) IDENTIFIER() antlr.TerminalNode { 28326 return s.GetToken(ParserIDENTIFIER, 0) 28327 } 28328 28329 func (s *Any_nameContext) Keyword() IKeywordContext { 28330 var t antlr.RuleContext 28331 for _, ctx := range s.GetChildren() { 28332 if _, ok := ctx.(IKeywordContext); ok { 28333 t = ctx.(antlr.RuleContext) 28334 break 28335 } 28336 } 28337 28338 if t == nil { 28339 return nil 28340 } 28341 28342 return t.(IKeywordContext) 28343 } 28344 28345 func (s *Any_nameContext) STRING_LITERAL() antlr.TerminalNode { 28346 return s.GetToken(ParserSTRING_LITERAL, 0) 28347 } 28348 28349 func (s *Any_nameContext) OPEN_PAR() antlr.TerminalNode { 28350 return s.GetToken(ParserOPEN_PAR, 0) 28351 } 28352 28353 func (s *Any_nameContext) Any_name() IAny_nameContext { 28354 var t antlr.RuleContext 28355 for _, ctx := range s.GetChildren() { 28356 if _, ok := ctx.(IAny_nameContext); ok { 28357 t = ctx.(antlr.RuleContext) 28358 break 28359 } 28360 } 28361 28362 if t == nil { 28363 return nil 28364 } 28365 28366 return t.(IAny_nameContext) 28367 } 28368 28369 func (s *Any_nameContext) CLOSE_PAR() antlr.TerminalNode { 28370 return s.GetToken(ParserCLOSE_PAR, 0) 28371 } 28372 28373 func (s *Any_nameContext) GetRuleContext() antlr.RuleContext { 28374 return s 28375 } 28376 28377 func (s *Any_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { 28378 return antlr.TreesStringTree(s, ruleNames, recog) 28379 } 28380 28381 func (s *Any_nameContext) EnterRule(listener antlr.ParseTreeListener) { 28382 if listenerT, ok := listener.(ParserListener); ok { 28383 listenerT.EnterAny_name(s) 28384 } 28385 } 28386 28387 func (s *Any_nameContext) ExitRule(listener antlr.ParseTreeListener) { 28388 if listenerT, ok := listener.(ParserListener); ok { 28389 listenerT.ExitAny_name(s) 28390 } 28391 } 28392 28393 func (s *Any_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { 28394 switch t := visitor.(type) { 28395 case ParserVisitor: 28396 return t.VisitAny_name(s) 28397 28398 default: 28399 return t.VisitChildren(s) 28400 } 28401 } 28402 28403 func (p *Parser) Any_name() (localctx IAny_nameContext) { 28404 this := p 28405 _ = this 28406 28407 localctx = NewAny_nameContext(p, p.GetParserRuleContext(), p.GetState()) 28408 p.EnterRule(localctx, 224, ParserRULE_any_name) 28409 28410 defer func() { 28411 p.ExitRule() 28412 }() 28413 28414 defer func() { 28415 if err := recover(); err != nil { 28416 if v, ok := err.(antlr.RecognitionException); ok { 28417 localctx.SetException(v) 28418 p.GetErrorHandler().ReportError(p, v) 28419 p.GetErrorHandler().Recover(p, v) 28420 } else { 28421 panic(err) 28422 } 28423 } 28424 }() 28425 28426 p.SetState(2080) 28427 p.GetErrorHandler().Sync(p) 28428 28429 switch p.GetTokenStream().LA(1) { 28430 case ParserIDENTIFIER: 28431 p.EnterOuterAlt(localctx, 1) 28432 { 28433 p.SetState(2073) 28434 p.Match(ParserIDENTIFIER) 28435 } 28436 28437 case ParserABORT_, ParserACTION_, ParserADD_, ParserAFTER_, ParserALL_, ParserALTER_, ParserANALYZE_, ParserAND_, ParserAS_, ParserASC_, ParserATTACH_, ParserAUTOINCREMENT_, ParserBEFORE_, ParserBEGIN_, ParserBETWEEN_, ParserBY_, ParserCASCADE_, ParserCASE_, ParserCAST_, ParserCHECK_, ParserCOLLATE_, ParserCOLUMN_, ParserCOMMIT_, ParserCONFLICT_, ParserCONSTRAINT_, ParserCREATE_, ParserCROSS_, ParserCURRENT_DATE_, ParserCURRENT_TIME_, ParserCURRENT_TIMESTAMP_, ParserDATABASE_, ParserDEFAULT_, ParserDEFERRABLE_, ParserDEFERRED_, ParserDELETE_, ParserDESC_, ParserDETACH_, ParserDISTINCT_, ParserDROP_, ParserEACH_, ParserELSE_, ParserEND_, ParserESCAPE_, ParserEXCEPT_, ParserEXCLUSIVE_, ParserEXISTS_, ParserEXPLAIN_, ParserFAIL_, ParserFOR_, ParserFOREIGN_, ParserFROM_, ParserFULL_, ParserGLOB_, ParserGROUP_, ParserHAVING_, ParserIF_, ParserIGNORE_, ParserIMMEDIATE_, ParserIN_, ParserINDEX_, ParserINDEXED_, ParserINITIALLY_, ParserINNER_, ParserINSERT_, ParserINSTEAD_, ParserINTERSECT_, ParserINTO_, ParserIS_, ParserISNULL_, ParserJOIN_, ParserKEY_, ParserLEFT_, ParserLIKE_, ParserLIMIT_, ParserMATCH_, ParserNATURAL_, ParserNO_, ParserNOT_, ParserNOTNULL_, ParserNULL_, ParserOF_, ParserOFFSET_, ParserON_, ParserOR_, ParserORDER_, ParserOUTER_, ParserPLAN_, ParserPRAGMA_, ParserPRIMARY_, ParserQUERY_, ParserRAISE_, ParserRECURSIVE_, ParserREFERENCES_, ParserREGEXP_, ParserREINDEX_, ParserRELEASE_, ParserRENAME_, ParserREPLACE_, ParserRESTRICT_, ParserRIGHT_, ParserROLLBACK_, ParserROW_, ParserROWS_, ParserSAVEPOINT_, ParserSELECT_, ParserSET_, ParserTABLE_, ParserTEMP_, ParserTEMPORARY_, ParserTHEN_, ParserTO_, ParserTRANSACTION_, ParserTRIGGER_, ParserUNION_, ParserUNIQUE_, ParserUPDATE_, ParserUSING_, ParserVACUUM_, ParserVALUES_, ParserVIEW_, ParserVIRTUAL_, ParserWHEN_, ParserWHERE_, ParserWITH_, ParserWITHOUT_, ParserFIRST_VALUE_, ParserOVER_, ParserPARTITION_, ParserRANGE_, ParserPRECEDING_, ParserUNBOUNDED_, ParserCURRENT_, ParserFOLLOWING_, ParserCUME_DIST_, ParserDENSE_RANK_, ParserLAG_, ParserLAST_VALUE_, ParserLEAD_, ParserNTH_VALUE_, ParserNTILE_, ParserPERCENT_RANK_, ParserRANK_, ParserROW_NUMBER_, ParserGENERATED_, ParserALWAYS_, ParserSTORED_, ParserTRUE_, ParserFALSE_, ParserWINDOW_, ParserNULLS_, ParserFIRST_, ParserLAST_, ParserFILTER_, ParserGROUPS_, ParserEXCLUDE_: 28438 p.EnterOuterAlt(localctx, 2) 28439 { 28440 p.SetState(2074) 28441 p.Keyword() 28442 } 28443 28444 case ParserSTRING_LITERAL: 28445 p.EnterOuterAlt(localctx, 3) 28446 { 28447 p.SetState(2075) 28448 p.Match(ParserSTRING_LITERAL) 28449 } 28450 28451 case ParserOPEN_PAR: 28452 p.EnterOuterAlt(localctx, 4) 28453 { 28454 p.SetState(2076) 28455 p.Match(ParserOPEN_PAR) 28456 } 28457 { 28458 p.SetState(2077) 28459 p.Any_name() 28460 } 28461 { 28462 p.SetState(2078) 28463 p.Match(ParserCLOSE_PAR) 28464 } 28465 28466 default: 28467 panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) 28468 } 28469 28470 return localctx 28471 } 28472 28473 func (p *Parser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool { 28474 switch ruleIndex { 28475 case 32: 28476 var t *ExprContext = nil 28477 if localctx != nil { 28478 t = localctx.(*ExprContext) 28479 } 28480 return p.Expr_Sempred(t, predIndex) 28481 28482 default: 28483 panic("No predicate with index: " + fmt.Sprint(ruleIndex)) 28484 } 28485 } 28486 28487 func (p *Parser) Expr_Sempred(localctx antlr.RuleContext, predIndex int) bool { 28488 this := p 28489 _ = this 28490 28491 switch predIndex { 28492 case 0: 28493 return p.Precpred(p.GetParserRuleContext(), 20) 28494 28495 case 1: 28496 return p.Precpred(p.GetParserRuleContext(), 19) 28497 28498 case 2: 28499 return p.Precpred(p.GetParserRuleContext(), 18) 28500 28501 case 3: 28502 return p.Precpred(p.GetParserRuleContext(), 17) 28503 28504 case 4: 28505 return p.Precpred(p.GetParserRuleContext(), 16) 28506 28507 case 5: 28508 return p.Precpred(p.GetParserRuleContext(), 15) 28509 28510 case 6: 28511 return p.Precpred(p.GetParserRuleContext(), 14) 28512 28513 case 7: 28514 return p.Precpred(p.GetParserRuleContext(), 13) 28515 28516 case 8: 28517 return p.Precpred(p.GetParserRuleContext(), 6) 28518 28519 case 9: 28520 return p.Precpred(p.GetParserRuleContext(), 5) 28521 28522 case 10: 28523 return p.Precpred(p.GetParserRuleContext(), 9) 28524 28525 case 11: 28526 return p.Precpred(p.GetParserRuleContext(), 8) 28527 28528 case 12: 28529 return p.Precpred(p.GetParserRuleContext(), 7) 28530 28531 case 13: 28532 return p.Precpred(p.GetParserRuleContext(), 4) 28533 28534 default: 28535 panic("No predicate with index: " + fmt.Sprint(predIndex)) 28536 } 28537 }