@plurnk/plurnk-mimetypes-text-sqlite 0.3.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +15 -0
- package/dist/TextSqlite.d.ts +7 -0
- package/dist/TextSqlite.d.ts.map +1 -0
- package/dist/TextSqlite.js +118 -0
- package/dist/TextSqlite.js.map +1 -0
- package/dist/generated/SQLiteLexer.d.ts +211 -0
- package/dist/generated/SQLiteLexer.d.ts.map +1 -0
- package/dist/generated/SQLiteLexer.js +946 -0
- package/dist/generated/SQLiteLexer.js.map +1 -0
- package/dist/generated/SQLiteParser.d.ts +1985 -0
- package/dist/generated/SQLiteParser.d.ts.map +1 -0
- package/dist/generated/SQLiteParser.js +15208 -0
- package/dist/generated/SQLiteParser.js.map +1 -0
- package/dist/generated/SQLiteParserVisitor.d.ts +809 -0
- package/dist/generated/SQLiteParserVisitor.d.ts.map +1 -0
- package/dist/generated/SQLiteParserVisitor.js +695 -0
- package/dist/generated/SQLiteParserVisitor.js.map +1 -0
- package/dist/index.d.ts +3 -0
- package/dist/index.d.ts.map +1 -0
- package/dist/index.js +3 -0
- package/dist/index.js.map +1 -0
- package/grammar/SQLiteLexer.g4 +245 -0
- package/grammar/SQLiteParser.g4 +935 -0
- package/package.json +56 -0
|
@@ -0,0 +1,1985 @@
|
|
|
1
|
+
import * as antlr from "antlr4ng";
|
|
2
|
+
import { Token } from "antlr4ng";
|
|
3
|
+
import { SQLiteParserVisitor } from "./SQLiteParserVisitor.ts";
|
|
4
|
+
export declare class SQLiteParser extends antlr.Parser {
|
|
5
|
+
static readonly SCOL = 1;
|
|
6
|
+
static readonly DOT = 2;
|
|
7
|
+
static readonly OPEN_PAR = 3;
|
|
8
|
+
static readonly CLOSE_PAR = 4;
|
|
9
|
+
static readonly COMMA = 5;
|
|
10
|
+
static readonly ASSIGN = 6;
|
|
11
|
+
static readonly STAR = 7;
|
|
12
|
+
static readonly PLUS = 8;
|
|
13
|
+
static readonly MINUS = 9;
|
|
14
|
+
static readonly TILDE = 10;
|
|
15
|
+
static readonly PIPE2 = 11;
|
|
16
|
+
static readonly DIV = 12;
|
|
17
|
+
static readonly MOD = 13;
|
|
18
|
+
static readonly LT2 = 14;
|
|
19
|
+
static readonly GT2 = 15;
|
|
20
|
+
static readonly AMP = 16;
|
|
21
|
+
static readonly PIPE = 17;
|
|
22
|
+
static readonly LT = 18;
|
|
23
|
+
static readonly LT_EQ = 19;
|
|
24
|
+
static readonly GT = 20;
|
|
25
|
+
static readonly GT_EQ = 21;
|
|
26
|
+
static readonly EQ = 22;
|
|
27
|
+
static readonly NOT_EQ1 = 23;
|
|
28
|
+
static readonly NOT_EQ2 = 24;
|
|
29
|
+
static readonly JPTR = 25;
|
|
30
|
+
static readonly JPTR2 = 26;
|
|
31
|
+
static readonly ABORT_ = 27;
|
|
32
|
+
static readonly ACTION_ = 28;
|
|
33
|
+
static readonly ADD_ = 29;
|
|
34
|
+
static readonly AFTER_ = 30;
|
|
35
|
+
static readonly ALL_ = 31;
|
|
36
|
+
static readonly ALTER_ = 32;
|
|
37
|
+
static readonly ALWAYS_ = 33;
|
|
38
|
+
static readonly ANALYZE_ = 34;
|
|
39
|
+
static readonly AND_ = 35;
|
|
40
|
+
static readonly AS_ = 36;
|
|
41
|
+
static readonly ASC_ = 37;
|
|
42
|
+
static readonly ATTACH_ = 38;
|
|
43
|
+
static readonly AUTOINCREMENT_ = 39;
|
|
44
|
+
static readonly BEFORE_ = 40;
|
|
45
|
+
static readonly BEGIN_ = 41;
|
|
46
|
+
static readonly BETWEEN_ = 42;
|
|
47
|
+
static readonly BY_ = 43;
|
|
48
|
+
static readonly CASCADE_ = 44;
|
|
49
|
+
static readonly CASE_ = 45;
|
|
50
|
+
static readonly CAST_ = 46;
|
|
51
|
+
static readonly CHECK_ = 47;
|
|
52
|
+
static readonly COLLATE_ = 48;
|
|
53
|
+
static readonly COLUMN_ = 49;
|
|
54
|
+
static readonly COMMIT_ = 50;
|
|
55
|
+
static readonly CONFLICT_ = 51;
|
|
56
|
+
static readonly CONSTRAINT_ = 52;
|
|
57
|
+
static readonly CREATE_ = 53;
|
|
58
|
+
static readonly CROSS_ = 54;
|
|
59
|
+
static readonly CURRENT_ = 55;
|
|
60
|
+
static readonly CURRENT_DATE_ = 56;
|
|
61
|
+
static readonly CURRENT_TIME_ = 57;
|
|
62
|
+
static readonly CURRENT_TIMESTAMP_ = 58;
|
|
63
|
+
static readonly DATABASE_ = 59;
|
|
64
|
+
static readonly DEFAULT_ = 60;
|
|
65
|
+
static readonly DEFERRABLE_ = 61;
|
|
66
|
+
static readonly DEFERRED_ = 62;
|
|
67
|
+
static readonly DELETE_ = 63;
|
|
68
|
+
static readonly DESC_ = 64;
|
|
69
|
+
static readonly DETACH_ = 65;
|
|
70
|
+
static readonly DISTINCT_ = 66;
|
|
71
|
+
static readonly DO_ = 67;
|
|
72
|
+
static readonly DROP_ = 68;
|
|
73
|
+
static readonly EACH_ = 69;
|
|
74
|
+
static readonly ELSE_ = 70;
|
|
75
|
+
static readonly END_ = 71;
|
|
76
|
+
static readonly ESCAPE_ = 72;
|
|
77
|
+
static readonly EXCEPT_ = 73;
|
|
78
|
+
static readonly EXCLUDE_ = 74;
|
|
79
|
+
static readonly EXCLUSIVE_ = 75;
|
|
80
|
+
static readonly EXISTS_ = 76;
|
|
81
|
+
static readonly EXPLAIN_ = 77;
|
|
82
|
+
static readonly FAIL_ = 78;
|
|
83
|
+
static readonly FALSE_ = 79;
|
|
84
|
+
static readonly FILTER_ = 80;
|
|
85
|
+
static readonly FIRST_ = 81;
|
|
86
|
+
static readonly FOLLOWING_ = 82;
|
|
87
|
+
static readonly FOR_ = 83;
|
|
88
|
+
static readonly FOREIGN_ = 84;
|
|
89
|
+
static readonly FROM_ = 85;
|
|
90
|
+
static readonly FULL_ = 86;
|
|
91
|
+
static readonly GENERATED_ = 87;
|
|
92
|
+
static readonly GLOB_ = 88;
|
|
93
|
+
static readonly GROUP_ = 89;
|
|
94
|
+
static readonly GROUPS_ = 90;
|
|
95
|
+
static readonly HAVING_ = 91;
|
|
96
|
+
static readonly IF_ = 92;
|
|
97
|
+
static readonly IGNORE_ = 93;
|
|
98
|
+
static readonly IMMEDIATE_ = 94;
|
|
99
|
+
static readonly IN_ = 95;
|
|
100
|
+
static readonly INDEX_ = 96;
|
|
101
|
+
static readonly INDEXED_ = 97;
|
|
102
|
+
static readonly INITIALLY_ = 98;
|
|
103
|
+
static readonly INNER_ = 99;
|
|
104
|
+
static readonly INSERT_ = 100;
|
|
105
|
+
static readonly INSTEAD_ = 101;
|
|
106
|
+
static readonly INTERSECT_ = 102;
|
|
107
|
+
static readonly INTO_ = 103;
|
|
108
|
+
static readonly IS_ = 104;
|
|
109
|
+
static readonly ISNULL_ = 105;
|
|
110
|
+
static readonly JOIN_ = 106;
|
|
111
|
+
static readonly KEY_ = 107;
|
|
112
|
+
static readonly LAST_ = 108;
|
|
113
|
+
static readonly LEFT_ = 109;
|
|
114
|
+
static readonly LIKE_ = 110;
|
|
115
|
+
static readonly LIMIT_ = 111;
|
|
116
|
+
static readonly MATCH_ = 112;
|
|
117
|
+
static readonly MATERIALIZED_ = 113;
|
|
118
|
+
static readonly NATURAL_ = 114;
|
|
119
|
+
static readonly NO_ = 115;
|
|
120
|
+
static readonly NOT_ = 116;
|
|
121
|
+
static readonly NOTHING_ = 117;
|
|
122
|
+
static readonly NOTNULL_ = 118;
|
|
123
|
+
static readonly NULL_ = 119;
|
|
124
|
+
static readonly NULLS_ = 120;
|
|
125
|
+
static readonly OF_ = 121;
|
|
126
|
+
static readonly OFFSET_ = 122;
|
|
127
|
+
static readonly ON_ = 123;
|
|
128
|
+
static readonly OR_ = 124;
|
|
129
|
+
static readonly ORDER_ = 125;
|
|
130
|
+
static readonly OTHERS_ = 126;
|
|
131
|
+
static readonly OUTER_ = 127;
|
|
132
|
+
static readonly OVER_ = 128;
|
|
133
|
+
static readonly PARTITION_ = 129;
|
|
134
|
+
static readonly PLAN_ = 130;
|
|
135
|
+
static readonly PRAGMA_ = 131;
|
|
136
|
+
static readonly PRECEDING_ = 132;
|
|
137
|
+
static readonly PRIMARY_ = 133;
|
|
138
|
+
static readonly QUERY_ = 134;
|
|
139
|
+
static readonly RAISE_ = 135;
|
|
140
|
+
static readonly RANGE_ = 136;
|
|
141
|
+
static readonly RECURSIVE_ = 137;
|
|
142
|
+
static readonly REFERENCES_ = 138;
|
|
143
|
+
static readonly REGEXP_ = 139;
|
|
144
|
+
static readonly REINDEX_ = 140;
|
|
145
|
+
static readonly RELEASE_ = 141;
|
|
146
|
+
static readonly RENAME_ = 142;
|
|
147
|
+
static readonly REPLACE_ = 143;
|
|
148
|
+
static readonly RESTRICT_ = 144;
|
|
149
|
+
static readonly RETURNING_ = 145;
|
|
150
|
+
static readonly RIGHT_ = 146;
|
|
151
|
+
static readonly ROLLBACK_ = 147;
|
|
152
|
+
static readonly ROW_ = 148;
|
|
153
|
+
static readonly ROWID_ = 149;
|
|
154
|
+
static readonly ROWS_ = 150;
|
|
155
|
+
static readonly SAVEPOINT_ = 151;
|
|
156
|
+
static readonly SELECT_ = 152;
|
|
157
|
+
static readonly SET_ = 153;
|
|
158
|
+
static readonly STORED_ = 154;
|
|
159
|
+
static readonly STRICT_ = 155;
|
|
160
|
+
static readonly TABLE_ = 156;
|
|
161
|
+
static readonly TEMP_ = 157;
|
|
162
|
+
static readonly TEMPORARY_ = 158;
|
|
163
|
+
static readonly THEN_ = 159;
|
|
164
|
+
static readonly TIES_ = 160;
|
|
165
|
+
static readonly TO_ = 161;
|
|
166
|
+
static readonly TRANSACTION_ = 162;
|
|
167
|
+
static readonly TRIGGER_ = 163;
|
|
168
|
+
static readonly TRUE_ = 164;
|
|
169
|
+
static readonly UNBOUNDED_ = 165;
|
|
170
|
+
static readonly UNION_ = 166;
|
|
171
|
+
static readonly UNIQUE_ = 167;
|
|
172
|
+
static readonly UPDATE_ = 168;
|
|
173
|
+
static readonly USING_ = 169;
|
|
174
|
+
static readonly VACUUM_ = 170;
|
|
175
|
+
static readonly VALUES_ = 171;
|
|
176
|
+
static readonly VIEW_ = 172;
|
|
177
|
+
static readonly VIRTUAL_ = 173;
|
|
178
|
+
static readonly WHEN_ = 174;
|
|
179
|
+
static readonly WHERE_ = 175;
|
|
180
|
+
static readonly WINDOW_ = 176;
|
|
181
|
+
static readonly WITH_ = 177;
|
|
182
|
+
static readonly WITHIN_ = 178;
|
|
183
|
+
static readonly WITHOUT_ = 179;
|
|
184
|
+
static readonly IDENTIFIER = 180;
|
|
185
|
+
static readonly NUMERIC_LITERAL = 181;
|
|
186
|
+
static readonly BIND_PARAMETER = 182;
|
|
187
|
+
static readonly STRING_LITERAL = 183;
|
|
188
|
+
static readonly BLOB_LITERAL = 184;
|
|
189
|
+
static readonly SINGLE_LINE_COMMENT = 185;
|
|
190
|
+
static readonly MULTILINE_COMMENT = 186;
|
|
191
|
+
static readonly SPACES = 187;
|
|
192
|
+
static readonly UNEXPECTED_CHAR = 188;
|
|
193
|
+
static readonly RULE_parse = 0;
|
|
194
|
+
static readonly RULE_sql_stmt_list = 1;
|
|
195
|
+
static readonly RULE_sql_stmt = 2;
|
|
196
|
+
static readonly RULE_alter_table_stmt = 3;
|
|
197
|
+
static readonly RULE_analyze_stmt = 4;
|
|
198
|
+
static readonly RULE_attach_stmt = 5;
|
|
199
|
+
static readonly RULE_begin_stmt = 6;
|
|
200
|
+
static readonly RULE_commit_stmt = 7;
|
|
201
|
+
static readonly RULE_rollback_stmt = 8;
|
|
202
|
+
static readonly RULE_savepoint_stmt = 9;
|
|
203
|
+
static readonly RULE_release_stmt = 10;
|
|
204
|
+
static readonly RULE_create_index_stmt = 11;
|
|
205
|
+
static readonly RULE_indexed_column = 12;
|
|
206
|
+
static readonly RULE_create_table_stmt = 13;
|
|
207
|
+
static readonly RULE_table_options = 14;
|
|
208
|
+
static readonly RULE_column_def = 15;
|
|
209
|
+
static readonly RULE_type_name = 16;
|
|
210
|
+
static readonly RULE_column_constraint = 17;
|
|
211
|
+
static readonly RULE_signed_number = 18;
|
|
212
|
+
static readonly RULE_table_constraint = 19;
|
|
213
|
+
static readonly RULE_foreign_key_clause = 20;
|
|
214
|
+
static readonly RULE_conflict_clause = 21;
|
|
215
|
+
static readonly RULE_create_trigger_stmt = 22;
|
|
216
|
+
static readonly RULE_create_view_stmt = 23;
|
|
217
|
+
static readonly RULE_create_virtual_table_stmt = 24;
|
|
218
|
+
static readonly RULE_with_clause = 25;
|
|
219
|
+
static readonly RULE_common_table_expression = 26;
|
|
220
|
+
static readonly RULE_cte_table_name = 27;
|
|
221
|
+
static readonly RULE_delete_stmt = 28;
|
|
222
|
+
static readonly RULE_detach_stmt = 29;
|
|
223
|
+
static readonly RULE_drop_stmt = 30;
|
|
224
|
+
static readonly RULE_expr = 31;
|
|
225
|
+
static readonly RULE_expr_or = 32;
|
|
226
|
+
static readonly RULE_expr_and = 33;
|
|
227
|
+
static readonly RULE_expr_not = 34;
|
|
228
|
+
static readonly RULE_expr_binary = 35;
|
|
229
|
+
static readonly RULE_expr_comparison = 36;
|
|
230
|
+
static readonly RULE_expr_bitwise = 37;
|
|
231
|
+
static readonly RULE_expr_addition = 38;
|
|
232
|
+
static readonly RULE_expr_multiplication = 39;
|
|
233
|
+
static readonly RULE_expr_string = 40;
|
|
234
|
+
static readonly RULE_expr_collate = 41;
|
|
235
|
+
static readonly RULE_expr_unary = 42;
|
|
236
|
+
static readonly RULE_expr_base = 43;
|
|
237
|
+
static readonly RULE_expr_recursive = 44;
|
|
238
|
+
static readonly RULE_raise_function = 45;
|
|
239
|
+
static readonly RULE_literal_value = 46;
|
|
240
|
+
static readonly RULE_percentile_clause = 47;
|
|
241
|
+
static readonly RULE_value_row = 48;
|
|
242
|
+
static readonly RULE_values_clause = 49;
|
|
243
|
+
static readonly RULE_insert_stmt = 50;
|
|
244
|
+
static readonly RULE_returning_clause = 51;
|
|
245
|
+
static readonly RULE_upsert_clause = 52;
|
|
246
|
+
static readonly RULE_pragma_stmt = 53;
|
|
247
|
+
static readonly RULE_pragma_value = 54;
|
|
248
|
+
static readonly RULE_reindex_stmt = 55;
|
|
249
|
+
static readonly RULE_select_stmt = 56;
|
|
250
|
+
static readonly RULE_join_clause = 57;
|
|
251
|
+
static readonly RULE_select_core = 58;
|
|
252
|
+
static readonly RULE_table_or_subquery = 59;
|
|
253
|
+
static readonly RULE_result_column = 60;
|
|
254
|
+
static readonly RULE_join_operator = 61;
|
|
255
|
+
static readonly RULE_join_constraint = 62;
|
|
256
|
+
static readonly RULE_compound_operator = 63;
|
|
257
|
+
static readonly RULE_update_stmt = 64;
|
|
258
|
+
static readonly RULE_column_name_list = 65;
|
|
259
|
+
static readonly RULE_qualified_table_name = 66;
|
|
260
|
+
static readonly RULE_vacuum_stmt = 67;
|
|
261
|
+
static readonly RULE_filter_clause = 68;
|
|
262
|
+
static readonly RULE_window_defn = 69;
|
|
263
|
+
static readonly RULE_over_clause = 70;
|
|
264
|
+
static readonly RULE_frame_spec = 71;
|
|
265
|
+
static readonly RULE_frame_clause = 72;
|
|
266
|
+
static readonly RULE_order_clause = 73;
|
|
267
|
+
static readonly RULE_limit_clause = 74;
|
|
268
|
+
static readonly RULE_ordering_term = 75;
|
|
269
|
+
static readonly RULE_asc_desc = 76;
|
|
270
|
+
static readonly RULE_frame_left = 77;
|
|
271
|
+
static readonly RULE_frame_right = 78;
|
|
272
|
+
static readonly RULE_frame_single = 79;
|
|
273
|
+
static readonly RULE_error_message = 80;
|
|
274
|
+
static readonly RULE_filename = 81;
|
|
275
|
+
static readonly RULE_module_argument = 82;
|
|
276
|
+
static readonly RULE_module_argument_outer = 83;
|
|
277
|
+
static readonly RULE_module_argument_inner = 84;
|
|
278
|
+
static readonly RULE_fallback_excluding_conflicts = 85;
|
|
279
|
+
static readonly RULE_join_keyword = 86;
|
|
280
|
+
static readonly RULE_fallback = 87;
|
|
281
|
+
static readonly RULE_name = 88;
|
|
282
|
+
static readonly RULE_function_name = 89;
|
|
283
|
+
static readonly RULE_schema_name = 90;
|
|
284
|
+
static readonly RULE_table_name = 91;
|
|
285
|
+
static readonly RULE_table_or_index_name = 92;
|
|
286
|
+
static readonly RULE_column_name = 93;
|
|
287
|
+
static readonly RULE_column_name_excluding_string = 94;
|
|
288
|
+
static readonly RULE_column_alias = 95;
|
|
289
|
+
static readonly RULE_collation_name = 96;
|
|
290
|
+
static readonly RULE_foreign_table = 97;
|
|
291
|
+
static readonly RULE_index_name = 98;
|
|
292
|
+
static readonly RULE_trigger_name = 99;
|
|
293
|
+
static readonly RULE_view_name = 100;
|
|
294
|
+
static readonly RULE_module_name = 101;
|
|
295
|
+
static readonly RULE_pragma_name = 102;
|
|
296
|
+
static readonly RULE_savepoint_name = 103;
|
|
297
|
+
static readonly RULE_table_alias = 104;
|
|
298
|
+
static readonly RULE_table_alias_excluding_joins = 105;
|
|
299
|
+
static readonly RULE_window_name = 106;
|
|
300
|
+
static readonly RULE_alias = 107;
|
|
301
|
+
static readonly RULE_base_window_name = 108;
|
|
302
|
+
static readonly RULE_table_function_name = 109;
|
|
303
|
+
static readonly RULE_any_name_excluding_raise = 110;
|
|
304
|
+
static readonly RULE_any_name_excluding_joins = 111;
|
|
305
|
+
static readonly RULE_any_name_excluding_string = 112;
|
|
306
|
+
static readonly RULE_any_name = 113;
|
|
307
|
+
static readonly literalNames: (string | null)[];
|
|
308
|
+
static readonly symbolicNames: (string | null)[];
|
|
309
|
+
static readonly ruleNames: string[];
|
|
310
|
+
get grammarFileName(): string;
|
|
311
|
+
get literalNames(): (string | null)[];
|
|
312
|
+
get symbolicNames(): (string | null)[];
|
|
313
|
+
get ruleNames(): string[];
|
|
314
|
+
get serializedATN(): number[];
|
|
315
|
+
protected createFailedPredicateException(predicate?: string, message?: string): antlr.FailedPredicateException;
|
|
316
|
+
constructor(input: antlr.TokenStream);
|
|
317
|
+
parse(): ParseContext;
|
|
318
|
+
sql_stmt_list(): Sql_stmt_listContext;
|
|
319
|
+
sql_stmt(): Sql_stmtContext;
|
|
320
|
+
alter_table_stmt(): Alter_table_stmtContext;
|
|
321
|
+
analyze_stmt(): Analyze_stmtContext;
|
|
322
|
+
attach_stmt(): Attach_stmtContext;
|
|
323
|
+
begin_stmt(): Begin_stmtContext;
|
|
324
|
+
commit_stmt(): Commit_stmtContext;
|
|
325
|
+
rollback_stmt(): Rollback_stmtContext;
|
|
326
|
+
savepoint_stmt(): Savepoint_stmtContext;
|
|
327
|
+
release_stmt(): Release_stmtContext;
|
|
328
|
+
create_index_stmt(): Create_index_stmtContext;
|
|
329
|
+
indexed_column(): Indexed_columnContext;
|
|
330
|
+
create_table_stmt(): Create_table_stmtContext;
|
|
331
|
+
table_options(): Table_optionsContext;
|
|
332
|
+
column_def(): Column_defContext;
|
|
333
|
+
type_name(): Type_nameContext;
|
|
334
|
+
column_constraint(): Column_constraintContext;
|
|
335
|
+
signed_number(): Signed_numberContext;
|
|
336
|
+
table_constraint(): Table_constraintContext;
|
|
337
|
+
foreign_key_clause(): Foreign_key_clauseContext;
|
|
338
|
+
conflict_clause(): Conflict_clauseContext;
|
|
339
|
+
create_trigger_stmt(): Create_trigger_stmtContext;
|
|
340
|
+
create_view_stmt(): Create_view_stmtContext;
|
|
341
|
+
create_virtual_table_stmt(): Create_virtual_table_stmtContext;
|
|
342
|
+
with_clause(): With_clauseContext;
|
|
343
|
+
common_table_expression(): Common_table_expressionContext;
|
|
344
|
+
cte_table_name(): Cte_table_nameContext;
|
|
345
|
+
delete_stmt(): Delete_stmtContext;
|
|
346
|
+
detach_stmt(): Detach_stmtContext;
|
|
347
|
+
drop_stmt(): Drop_stmtContext;
|
|
348
|
+
expr(): ExprContext;
|
|
349
|
+
expr_or(): Expr_orContext;
|
|
350
|
+
expr_and(): Expr_andContext;
|
|
351
|
+
expr_not(): Expr_notContext;
|
|
352
|
+
expr_binary(): Expr_binaryContext;
|
|
353
|
+
expr_comparison(): Expr_comparisonContext;
|
|
354
|
+
expr_bitwise(): Expr_bitwiseContext;
|
|
355
|
+
expr_addition(): Expr_additionContext;
|
|
356
|
+
expr_multiplication(): Expr_multiplicationContext;
|
|
357
|
+
expr_string(): Expr_stringContext;
|
|
358
|
+
expr_collate(): Expr_collateContext;
|
|
359
|
+
expr_unary(): Expr_unaryContext;
|
|
360
|
+
expr_base(): Expr_baseContext;
|
|
361
|
+
expr_recursive(): Expr_recursiveContext;
|
|
362
|
+
raise_function(): Raise_functionContext;
|
|
363
|
+
literal_value(): Literal_valueContext;
|
|
364
|
+
percentile_clause(): Percentile_clauseContext;
|
|
365
|
+
value_row(): Value_rowContext;
|
|
366
|
+
values_clause(): Values_clauseContext;
|
|
367
|
+
insert_stmt(): Insert_stmtContext;
|
|
368
|
+
returning_clause(): Returning_clauseContext;
|
|
369
|
+
upsert_clause(): Upsert_clauseContext;
|
|
370
|
+
pragma_stmt(): Pragma_stmtContext;
|
|
371
|
+
pragma_value(): Pragma_valueContext;
|
|
372
|
+
reindex_stmt(): Reindex_stmtContext;
|
|
373
|
+
select_stmt(): Select_stmtContext;
|
|
374
|
+
join_clause(): Join_clauseContext;
|
|
375
|
+
select_core(): Select_coreContext;
|
|
376
|
+
table_or_subquery(): Table_or_subqueryContext;
|
|
377
|
+
result_column(): Result_columnContext;
|
|
378
|
+
join_operator(): Join_operatorContext;
|
|
379
|
+
join_constraint(): Join_constraintContext;
|
|
380
|
+
compound_operator(): Compound_operatorContext;
|
|
381
|
+
update_stmt(): Update_stmtContext;
|
|
382
|
+
column_name_list(): Column_name_listContext;
|
|
383
|
+
qualified_table_name(): Qualified_table_nameContext;
|
|
384
|
+
vacuum_stmt(): Vacuum_stmtContext;
|
|
385
|
+
filter_clause(): Filter_clauseContext;
|
|
386
|
+
window_defn(): Window_defnContext;
|
|
387
|
+
over_clause(): Over_clauseContext;
|
|
388
|
+
frame_spec(): Frame_specContext;
|
|
389
|
+
frame_clause(): Frame_clauseContext;
|
|
390
|
+
order_clause(): Order_clauseContext;
|
|
391
|
+
limit_clause(): Limit_clauseContext;
|
|
392
|
+
ordering_term(): Ordering_termContext;
|
|
393
|
+
asc_desc(): Asc_descContext;
|
|
394
|
+
frame_left(): Frame_leftContext;
|
|
395
|
+
frame_right(): Frame_rightContext;
|
|
396
|
+
frame_single(): Frame_singleContext;
|
|
397
|
+
error_message(): Error_messageContext;
|
|
398
|
+
filename(): FilenameContext;
|
|
399
|
+
module_argument(): Module_argumentContext;
|
|
400
|
+
module_argument_outer(): Module_argument_outerContext;
|
|
401
|
+
module_argument_inner(): Module_argument_innerContext;
|
|
402
|
+
fallback_excluding_conflicts(): Fallback_excluding_conflictsContext;
|
|
403
|
+
join_keyword(): Join_keywordContext;
|
|
404
|
+
fallback(): FallbackContext;
|
|
405
|
+
name(): NameContext;
|
|
406
|
+
function_name(): Function_nameContext;
|
|
407
|
+
schema_name(): Schema_nameContext;
|
|
408
|
+
table_name(): Table_nameContext;
|
|
409
|
+
table_or_index_name(): Table_or_index_nameContext;
|
|
410
|
+
column_name(): Column_nameContext;
|
|
411
|
+
column_name_excluding_string(): Column_name_excluding_stringContext;
|
|
412
|
+
column_alias(): Column_aliasContext;
|
|
413
|
+
collation_name(): Collation_nameContext;
|
|
414
|
+
foreign_table(): Foreign_tableContext;
|
|
415
|
+
index_name(): Index_nameContext;
|
|
416
|
+
trigger_name(): Trigger_nameContext;
|
|
417
|
+
view_name(): View_nameContext;
|
|
418
|
+
module_name(): Module_nameContext;
|
|
419
|
+
pragma_name(): Pragma_nameContext;
|
|
420
|
+
savepoint_name(): Savepoint_nameContext;
|
|
421
|
+
table_alias(): Table_aliasContext;
|
|
422
|
+
table_alias_excluding_joins(): Table_alias_excluding_joinsContext;
|
|
423
|
+
window_name(): Window_nameContext;
|
|
424
|
+
alias(): AliasContext;
|
|
425
|
+
base_window_name(): Base_window_nameContext;
|
|
426
|
+
table_function_name(): Table_function_nameContext;
|
|
427
|
+
any_name_excluding_raise(): Any_name_excluding_raiseContext;
|
|
428
|
+
any_name_excluding_joins(): Any_name_excluding_joinsContext;
|
|
429
|
+
any_name_excluding_string(): Any_name_excluding_stringContext;
|
|
430
|
+
any_name(): Any_nameContext;
|
|
431
|
+
static readonly _serializedATN: number[];
|
|
432
|
+
private static __ATN;
|
|
433
|
+
static get _ATN(): antlr.ATN;
|
|
434
|
+
private static readonly vocabulary;
|
|
435
|
+
get vocabulary(): antlr.Vocabulary;
|
|
436
|
+
private static readonly decisionsToDFA;
|
|
437
|
+
}
|
|
438
|
+
export declare class ParseContext extends antlr.ParserRuleContext {
|
|
439
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
440
|
+
sql_stmt_list(): Sql_stmt_listContext;
|
|
441
|
+
EOF(): antlr.TerminalNode;
|
|
442
|
+
get ruleIndex(): number;
|
|
443
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
444
|
+
}
|
|
445
|
+
export declare class Sql_stmt_listContext extends antlr.ParserRuleContext {
|
|
446
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
447
|
+
sql_stmt(): Sql_stmtContext[];
|
|
448
|
+
sql_stmt(i: number): Sql_stmtContext | null;
|
|
449
|
+
SCOL(): antlr.TerminalNode[];
|
|
450
|
+
SCOL(i: number): antlr.TerminalNode | null;
|
|
451
|
+
get ruleIndex(): number;
|
|
452
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
453
|
+
}
|
|
454
|
+
export declare class Sql_stmtContext extends antlr.ParserRuleContext {
|
|
455
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
456
|
+
alter_table_stmt(): Alter_table_stmtContext | null;
|
|
457
|
+
analyze_stmt(): Analyze_stmtContext | null;
|
|
458
|
+
attach_stmt(): Attach_stmtContext | null;
|
|
459
|
+
begin_stmt(): Begin_stmtContext | null;
|
|
460
|
+
commit_stmt(): Commit_stmtContext | null;
|
|
461
|
+
create_index_stmt(): Create_index_stmtContext | null;
|
|
462
|
+
create_table_stmt(): Create_table_stmtContext | null;
|
|
463
|
+
create_trigger_stmt(): Create_trigger_stmtContext | null;
|
|
464
|
+
create_view_stmt(): Create_view_stmtContext | null;
|
|
465
|
+
create_virtual_table_stmt(): Create_virtual_table_stmtContext | null;
|
|
466
|
+
delete_stmt(): Delete_stmtContext | null;
|
|
467
|
+
detach_stmt(): Detach_stmtContext | null;
|
|
468
|
+
drop_stmt(): Drop_stmtContext | null;
|
|
469
|
+
insert_stmt(): Insert_stmtContext | null;
|
|
470
|
+
pragma_stmt(): Pragma_stmtContext | null;
|
|
471
|
+
reindex_stmt(): Reindex_stmtContext | null;
|
|
472
|
+
release_stmt(): Release_stmtContext | null;
|
|
473
|
+
rollback_stmt(): Rollback_stmtContext | null;
|
|
474
|
+
savepoint_stmt(): Savepoint_stmtContext | null;
|
|
475
|
+
select_stmt(): Select_stmtContext | null;
|
|
476
|
+
update_stmt(): Update_stmtContext | null;
|
|
477
|
+
vacuum_stmt(): Vacuum_stmtContext | null;
|
|
478
|
+
EXPLAIN_(): antlr.TerminalNode | null;
|
|
479
|
+
QUERY_(): antlr.TerminalNode | null;
|
|
480
|
+
PLAN_(): antlr.TerminalNode | null;
|
|
481
|
+
get ruleIndex(): number;
|
|
482
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
483
|
+
}
|
|
484
|
+
export declare class Alter_table_stmtContext extends antlr.ParserRuleContext {
|
|
485
|
+
_new_table_name?: Table_nameContext;
|
|
486
|
+
_old_column_name?: Column_nameContext;
|
|
487
|
+
_new_column_name?: Column_nameContext;
|
|
488
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
489
|
+
ALTER_(): antlr.TerminalNode;
|
|
490
|
+
TABLE_(): antlr.TerminalNode;
|
|
491
|
+
table_name(): Table_nameContext[];
|
|
492
|
+
table_name(i: number): Table_nameContext | null;
|
|
493
|
+
RENAME_(): antlr.TerminalNode | null;
|
|
494
|
+
ADD_(): antlr.TerminalNode | null;
|
|
495
|
+
column_def(): Column_defContext | null;
|
|
496
|
+
DROP_(): antlr.TerminalNode | null;
|
|
497
|
+
column_name(): Column_nameContext[];
|
|
498
|
+
column_name(i: number): Column_nameContext | null;
|
|
499
|
+
schema_name(): Schema_nameContext | null;
|
|
500
|
+
DOT(): antlr.TerminalNode | null;
|
|
501
|
+
TO_(): antlr.TerminalNode | null;
|
|
502
|
+
COLUMN_(): antlr.TerminalNode | null;
|
|
503
|
+
get ruleIndex(): number;
|
|
504
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
505
|
+
}
|
|
506
|
+
export declare class Analyze_stmtContext extends antlr.ParserRuleContext {
|
|
507
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
508
|
+
ANALYZE_(): antlr.TerminalNode;
|
|
509
|
+
schema_name(): Schema_nameContext | null;
|
|
510
|
+
table_or_index_name(): Table_or_index_nameContext | null;
|
|
511
|
+
DOT(): antlr.TerminalNode | null;
|
|
512
|
+
get ruleIndex(): number;
|
|
513
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
514
|
+
}
|
|
515
|
+
export declare class Attach_stmtContext extends antlr.ParserRuleContext {
|
|
516
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
517
|
+
ATTACH_(): antlr.TerminalNode;
|
|
518
|
+
expr(): ExprContext;
|
|
519
|
+
AS_(): antlr.TerminalNode;
|
|
520
|
+
schema_name(): Schema_nameContext;
|
|
521
|
+
DATABASE_(): antlr.TerminalNode | null;
|
|
522
|
+
get ruleIndex(): number;
|
|
523
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
524
|
+
}
|
|
525
|
+
export declare class Begin_stmtContext extends antlr.ParserRuleContext {
|
|
526
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
527
|
+
BEGIN_(): antlr.TerminalNode;
|
|
528
|
+
TRANSACTION_(): antlr.TerminalNode | null;
|
|
529
|
+
DEFERRED_(): antlr.TerminalNode | null;
|
|
530
|
+
IMMEDIATE_(): antlr.TerminalNode | null;
|
|
531
|
+
EXCLUSIVE_(): antlr.TerminalNode | null;
|
|
532
|
+
get ruleIndex(): number;
|
|
533
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
534
|
+
}
|
|
535
|
+
export declare class Commit_stmtContext extends antlr.ParserRuleContext {
|
|
536
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
537
|
+
COMMIT_(): antlr.TerminalNode | null;
|
|
538
|
+
END_(): antlr.TerminalNode | null;
|
|
539
|
+
TRANSACTION_(): antlr.TerminalNode | null;
|
|
540
|
+
get ruleIndex(): number;
|
|
541
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
542
|
+
}
|
|
543
|
+
export declare class Rollback_stmtContext extends antlr.ParserRuleContext {
|
|
544
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
545
|
+
ROLLBACK_(): antlr.TerminalNode;
|
|
546
|
+
TRANSACTION_(): antlr.TerminalNode | null;
|
|
547
|
+
TO_(): antlr.TerminalNode | null;
|
|
548
|
+
savepoint_name(): Savepoint_nameContext | null;
|
|
549
|
+
SAVEPOINT_(): antlr.TerminalNode | null;
|
|
550
|
+
get ruleIndex(): number;
|
|
551
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
552
|
+
}
|
|
553
|
+
export declare class Savepoint_stmtContext extends antlr.ParserRuleContext {
|
|
554
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
555
|
+
SAVEPOINT_(): antlr.TerminalNode;
|
|
556
|
+
savepoint_name(): Savepoint_nameContext;
|
|
557
|
+
get ruleIndex(): number;
|
|
558
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
559
|
+
}
|
|
560
|
+
export declare class Release_stmtContext extends antlr.ParserRuleContext {
|
|
561
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
562
|
+
RELEASE_(): antlr.TerminalNode;
|
|
563
|
+
savepoint_name(): Savepoint_nameContext;
|
|
564
|
+
SAVEPOINT_(): antlr.TerminalNode | null;
|
|
565
|
+
get ruleIndex(): number;
|
|
566
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
567
|
+
}
|
|
568
|
+
export declare class Create_index_stmtContext extends antlr.ParserRuleContext {
|
|
569
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
570
|
+
CREATE_(): antlr.TerminalNode;
|
|
571
|
+
INDEX_(): antlr.TerminalNode;
|
|
572
|
+
index_name(): Index_nameContext;
|
|
573
|
+
ON_(): antlr.TerminalNode;
|
|
574
|
+
table_name(): Table_nameContext;
|
|
575
|
+
OPEN_PAR(): antlr.TerminalNode;
|
|
576
|
+
indexed_column(): Indexed_columnContext[];
|
|
577
|
+
indexed_column(i: number): Indexed_columnContext | null;
|
|
578
|
+
CLOSE_PAR(): antlr.TerminalNode;
|
|
579
|
+
UNIQUE_(): antlr.TerminalNode | null;
|
|
580
|
+
IF_(): antlr.TerminalNode | null;
|
|
581
|
+
NOT_(): antlr.TerminalNode | null;
|
|
582
|
+
EXISTS_(): antlr.TerminalNode | null;
|
|
583
|
+
schema_name(): Schema_nameContext | null;
|
|
584
|
+
DOT(): antlr.TerminalNode | null;
|
|
585
|
+
COMMA(): antlr.TerminalNode[];
|
|
586
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
587
|
+
WHERE_(): antlr.TerminalNode | null;
|
|
588
|
+
expr(): ExprContext | null;
|
|
589
|
+
get ruleIndex(): number;
|
|
590
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
591
|
+
}
|
|
592
|
+
export declare class Indexed_columnContext extends antlr.ParserRuleContext {
|
|
593
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
594
|
+
expr(): ExprContext;
|
|
595
|
+
COLLATE_(): antlr.TerminalNode | null;
|
|
596
|
+
collation_name(): Collation_nameContext | null;
|
|
597
|
+
asc_desc(): Asc_descContext | null;
|
|
598
|
+
get ruleIndex(): number;
|
|
599
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
600
|
+
}
|
|
601
|
+
export declare class Create_table_stmtContext extends antlr.ParserRuleContext {
|
|
602
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
603
|
+
CREATE_(): antlr.TerminalNode;
|
|
604
|
+
TABLE_(): antlr.TerminalNode;
|
|
605
|
+
table_name(): Table_nameContext;
|
|
606
|
+
OPEN_PAR(): antlr.TerminalNode | null;
|
|
607
|
+
column_def(): Column_defContext[];
|
|
608
|
+
column_def(i: number): Column_defContext | null;
|
|
609
|
+
CLOSE_PAR(): antlr.TerminalNode | null;
|
|
610
|
+
AS_(): antlr.TerminalNode | null;
|
|
611
|
+
select_stmt(): Select_stmtContext | null;
|
|
612
|
+
IF_(): antlr.TerminalNode | null;
|
|
613
|
+
NOT_(): antlr.TerminalNode | null;
|
|
614
|
+
EXISTS_(): antlr.TerminalNode | null;
|
|
615
|
+
schema_name(): Schema_nameContext | null;
|
|
616
|
+
DOT(): antlr.TerminalNode | null;
|
|
617
|
+
TEMP_(): antlr.TerminalNode | null;
|
|
618
|
+
TEMPORARY_(): antlr.TerminalNode | null;
|
|
619
|
+
COMMA(): antlr.TerminalNode[];
|
|
620
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
621
|
+
table_constraint(): Table_constraintContext[];
|
|
622
|
+
table_constraint(i: number): Table_constraintContext | null;
|
|
623
|
+
table_options(): Table_optionsContext | null;
|
|
624
|
+
get ruleIndex(): number;
|
|
625
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
626
|
+
}
|
|
627
|
+
export declare class Table_optionsContext extends antlr.ParserRuleContext {
|
|
628
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
629
|
+
WITHOUT_(): antlr.TerminalNode[];
|
|
630
|
+
WITHOUT_(i: number): antlr.TerminalNode | null;
|
|
631
|
+
ROWID_(): antlr.TerminalNode[];
|
|
632
|
+
ROWID_(i: number): antlr.TerminalNode | null;
|
|
633
|
+
STRICT_(): antlr.TerminalNode[];
|
|
634
|
+
STRICT_(i: number): antlr.TerminalNode | null;
|
|
635
|
+
COMMA(): antlr.TerminalNode[];
|
|
636
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
637
|
+
get ruleIndex(): number;
|
|
638
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
639
|
+
}
|
|
640
|
+
export declare class Column_defContext extends antlr.ParserRuleContext {
|
|
641
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
642
|
+
column_name(): Column_nameContext;
|
|
643
|
+
type_name(): Type_nameContext | null;
|
|
644
|
+
column_constraint(): Column_constraintContext[];
|
|
645
|
+
column_constraint(i: number): Column_constraintContext | null;
|
|
646
|
+
get ruleIndex(): number;
|
|
647
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
648
|
+
}
|
|
649
|
+
export declare class Type_nameContext extends antlr.ParserRuleContext {
|
|
650
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
651
|
+
name(): NameContext[];
|
|
652
|
+
name(i: number): NameContext | null;
|
|
653
|
+
OPEN_PAR(): antlr.TerminalNode | null;
|
|
654
|
+
signed_number(): Signed_numberContext[];
|
|
655
|
+
signed_number(i: number): Signed_numberContext | null;
|
|
656
|
+
CLOSE_PAR(): antlr.TerminalNode | null;
|
|
657
|
+
COMMA(): antlr.TerminalNode | null;
|
|
658
|
+
get ruleIndex(): number;
|
|
659
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
660
|
+
}
|
|
661
|
+
export declare class Column_constraintContext extends antlr.ParserRuleContext {
|
|
662
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
663
|
+
PRIMARY_(): antlr.TerminalNode | null;
|
|
664
|
+
KEY_(): antlr.TerminalNode | null;
|
|
665
|
+
CHECK_(): antlr.TerminalNode | null;
|
|
666
|
+
OPEN_PAR(): antlr.TerminalNode | null;
|
|
667
|
+
expr(): ExprContext | null;
|
|
668
|
+
CLOSE_PAR(): antlr.TerminalNode | null;
|
|
669
|
+
DEFAULT_(): antlr.TerminalNode | null;
|
|
670
|
+
COLLATE_(): antlr.TerminalNode | null;
|
|
671
|
+
collation_name(): Collation_nameContext | null;
|
|
672
|
+
foreign_key_clause(): Foreign_key_clauseContext | null;
|
|
673
|
+
AS_(): antlr.TerminalNode | null;
|
|
674
|
+
CONSTRAINT_(): antlr.TerminalNode | null;
|
|
675
|
+
name(): NameContext | null;
|
|
676
|
+
NULL_(): antlr.TerminalNode | null;
|
|
677
|
+
UNIQUE_(): antlr.TerminalNode | null;
|
|
678
|
+
signed_number(): Signed_numberContext | null;
|
|
679
|
+
literal_value(): Literal_valueContext | null;
|
|
680
|
+
asc_desc(): Asc_descContext | null;
|
|
681
|
+
conflict_clause(): Conflict_clauseContext | null;
|
|
682
|
+
AUTOINCREMENT_(): antlr.TerminalNode | null;
|
|
683
|
+
GENERATED_(): antlr.TerminalNode | null;
|
|
684
|
+
ALWAYS_(): antlr.TerminalNode | null;
|
|
685
|
+
STORED_(): antlr.TerminalNode | null;
|
|
686
|
+
VIRTUAL_(): antlr.TerminalNode | null;
|
|
687
|
+
NOT_(): antlr.TerminalNode | null;
|
|
688
|
+
get ruleIndex(): number;
|
|
689
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
690
|
+
}
|
|
691
|
+
export declare class Signed_numberContext extends antlr.ParserRuleContext {
|
|
692
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
693
|
+
NUMERIC_LITERAL(): antlr.TerminalNode;
|
|
694
|
+
PLUS(): antlr.TerminalNode | null;
|
|
695
|
+
MINUS(): antlr.TerminalNode | null;
|
|
696
|
+
get ruleIndex(): number;
|
|
697
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
698
|
+
}
|
|
699
|
+
export declare class Table_constraintContext extends antlr.ParserRuleContext {
|
|
700
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
701
|
+
OPEN_PAR(): antlr.TerminalNode | null;
|
|
702
|
+
indexed_column(): Indexed_columnContext[];
|
|
703
|
+
indexed_column(i: number): Indexed_columnContext | null;
|
|
704
|
+
CLOSE_PAR(): antlr.TerminalNode | null;
|
|
705
|
+
CHECK_(): antlr.TerminalNode | null;
|
|
706
|
+
expr(): ExprContext | null;
|
|
707
|
+
FOREIGN_(): antlr.TerminalNode | null;
|
|
708
|
+
KEY_(): antlr.TerminalNode | null;
|
|
709
|
+
column_name(): Column_nameContext[];
|
|
710
|
+
column_name(i: number): Column_nameContext | null;
|
|
711
|
+
foreign_key_clause(): Foreign_key_clauseContext | null;
|
|
712
|
+
CONSTRAINT_(): antlr.TerminalNode | null;
|
|
713
|
+
name(): NameContext | null;
|
|
714
|
+
PRIMARY_(): antlr.TerminalNode | null;
|
|
715
|
+
UNIQUE_(): antlr.TerminalNode | null;
|
|
716
|
+
COMMA(): antlr.TerminalNode[];
|
|
717
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
718
|
+
conflict_clause(): Conflict_clauseContext | null;
|
|
719
|
+
get ruleIndex(): number;
|
|
720
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
721
|
+
}
|
|
722
|
+
export declare class Foreign_key_clauseContext extends antlr.ParserRuleContext {
|
|
723
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
724
|
+
REFERENCES_(): antlr.TerminalNode;
|
|
725
|
+
foreign_table(): Foreign_tableContext;
|
|
726
|
+
OPEN_PAR(): antlr.TerminalNode | null;
|
|
727
|
+
column_name(): Column_nameContext[];
|
|
728
|
+
column_name(i: number): Column_nameContext | null;
|
|
729
|
+
CLOSE_PAR(): antlr.TerminalNode | null;
|
|
730
|
+
ON_(): antlr.TerminalNode[];
|
|
731
|
+
ON_(i: number): antlr.TerminalNode | null;
|
|
732
|
+
MATCH_(): antlr.TerminalNode[];
|
|
733
|
+
MATCH_(i: number): antlr.TerminalNode | null;
|
|
734
|
+
name(): NameContext[];
|
|
735
|
+
name(i: number): NameContext | null;
|
|
736
|
+
DEFERRABLE_(): antlr.TerminalNode | null;
|
|
737
|
+
DELETE_(): antlr.TerminalNode[];
|
|
738
|
+
DELETE_(i: number): antlr.TerminalNode | null;
|
|
739
|
+
UPDATE_(): antlr.TerminalNode[];
|
|
740
|
+
UPDATE_(i: number): antlr.TerminalNode | null;
|
|
741
|
+
SET_(): antlr.TerminalNode[];
|
|
742
|
+
SET_(i: number): antlr.TerminalNode | null;
|
|
743
|
+
CASCADE_(): antlr.TerminalNode[];
|
|
744
|
+
CASCADE_(i: number): antlr.TerminalNode | null;
|
|
745
|
+
RESTRICT_(): antlr.TerminalNode[];
|
|
746
|
+
RESTRICT_(i: number): antlr.TerminalNode | null;
|
|
747
|
+
NO_(): antlr.TerminalNode[];
|
|
748
|
+
NO_(i: number): antlr.TerminalNode | null;
|
|
749
|
+
ACTION_(): antlr.TerminalNode[];
|
|
750
|
+
ACTION_(i: number): antlr.TerminalNode | null;
|
|
751
|
+
COMMA(): antlr.TerminalNode[];
|
|
752
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
753
|
+
NULL_(): antlr.TerminalNode[];
|
|
754
|
+
NULL_(i: number): antlr.TerminalNode | null;
|
|
755
|
+
DEFAULT_(): antlr.TerminalNode[];
|
|
756
|
+
DEFAULT_(i: number): antlr.TerminalNode | null;
|
|
757
|
+
NOT_(): antlr.TerminalNode | null;
|
|
758
|
+
INITIALLY_(): antlr.TerminalNode | null;
|
|
759
|
+
DEFERRED_(): antlr.TerminalNode | null;
|
|
760
|
+
IMMEDIATE_(): antlr.TerminalNode | null;
|
|
761
|
+
get ruleIndex(): number;
|
|
762
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
763
|
+
}
|
|
764
|
+
export declare class Conflict_clauseContext extends antlr.ParserRuleContext {
|
|
765
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
766
|
+
ON_(): antlr.TerminalNode;
|
|
767
|
+
CONFLICT_(): antlr.TerminalNode;
|
|
768
|
+
ROLLBACK_(): antlr.TerminalNode | null;
|
|
769
|
+
ABORT_(): antlr.TerminalNode | null;
|
|
770
|
+
FAIL_(): antlr.TerminalNode | null;
|
|
771
|
+
IGNORE_(): antlr.TerminalNode | null;
|
|
772
|
+
REPLACE_(): antlr.TerminalNode | null;
|
|
773
|
+
get ruleIndex(): number;
|
|
774
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
775
|
+
}
|
|
776
|
+
export declare class Create_trigger_stmtContext extends antlr.ParserRuleContext {
|
|
777
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
778
|
+
CREATE_(): antlr.TerminalNode;
|
|
779
|
+
TRIGGER_(): antlr.TerminalNode;
|
|
780
|
+
trigger_name(): Trigger_nameContext;
|
|
781
|
+
ON_(): antlr.TerminalNode;
|
|
782
|
+
table_name(): Table_nameContext;
|
|
783
|
+
BEGIN_(): antlr.TerminalNode;
|
|
784
|
+
END_(): antlr.TerminalNode;
|
|
785
|
+
DELETE_(): antlr.TerminalNode | null;
|
|
786
|
+
INSERT_(): antlr.TerminalNode | null;
|
|
787
|
+
UPDATE_(): antlr.TerminalNode | null;
|
|
788
|
+
IF_(): antlr.TerminalNode | null;
|
|
789
|
+
NOT_(): antlr.TerminalNode | null;
|
|
790
|
+
EXISTS_(): antlr.TerminalNode | null;
|
|
791
|
+
schema_name(): Schema_nameContext | null;
|
|
792
|
+
DOT(): antlr.TerminalNode | null;
|
|
793
|
+
BEFORE_(): antlr.TerminalNode | null;
|
|
794
|
+
AFTER_(): antlr.TerminalNode | null;
|
|
795
|
+
INSTEAD_(): antlr.TerminalNode | null;
|
|
796
|
+
OF_(): antlr.TerminalNode[];
|
|
797
|
+
OF_(i: number): antlr.TerminalNode | null;
|
|
798
|
+
FOR_(): antlr.TerminalNode | null;
|
|
799
|
+
EACH_(): antlr.TerminalNode | null;
|
|
800
|
+
ROW_(): antlr.TerminalNode | null;
|
|
801
|
+
WHEN_(): antlr.TerminalNode | null;
|
|
802
|
+
expr(): ExprContext | null;
|
|
803
|
+
SCOL(): antlr.TerminalNode[];
|
|
804
|
+
SCOL(i: number): antlr.TerminalNode | null;
|
|
805
|
+
TEMP_(): antlr.TerminalNode | null;
|
|
806
|
+
TEMPORARY_(): antlr.TerminalNode | null;
|
|
807
|
+
column_name(): Column_nameContext[];
|
|
808
|
+
column_name(i: number): Column_nameContext | null;
|
|
809
|
+
update_stmt(): Update_stmtContext[];
|
|
810
|
+
update_stmt(i: number): Update_stmtContext | null;
|
|
811
|
+
insert_stmt(): Insert_stmtContext[];
|
|
812
|
+
insert_stmt(i: number): Insert_stmtContext | null;
|
|
813
|
+
delete_stmt(): Delete_stmtContext[];
|
|
814
|
+
delete_stmt(i: number): Delete_stmtContext | null;
|
|
815
|
+
select_stmt(): Select_stmtContext[];
|
|
816
|
+
select_stmt(i: number): Select_stmtContext | null;
|
|
817
|
+
COMMA(): antlr.TerminalNode[];
|
|
818
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
819
|
+
get ruleIndex(): number;
|
|
820
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
821
|
+
}
|
|
822
|
+
export declare class Create_view_stmtContext extends antlr.ParserRuleContext {
|
|
823
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
824
|
+
CREATE_(): antlr.TerminalNode;
|
|
825
|
+
VIEW_(): antlr.TerminalNode;
|
|
826
|
+
view_name(): View_nameContext;
|
|
827
|
+
AS_(): antlr.TerminalNode;
|
|
828
|
+
select_stmt(): Select_stmtContext;
|
|
829
|
+
IF_(): antlr.TerminalNode | null;
|
|
830
|
+
NOT_(): antlr.TerminalNode | null;
|
|
831
|
+
EXISTS_(): antlr.TerminalNode | null;
|
|
832
|
+
schema_name(): Schema_nameContext | null;
|
|
833
|
+
DOT(): antlr.TerminalNode | null;
|
|
834
|
+
OPEN_PAR(): antlr.TerminalNode | null;
|
|
835
|
+
column_name(): Column_nameContext[];
|
|
836
|
+
column_name(i: number): Column_nameContext | null;
|
|
837
|
+
CLOSE_PAR(): antlr.TerminalNode | null;
|
|
838
|
+
TEMP_(): antlr.TerminalNode | null;
|
|
839
|
+
TEMPORARY_(): antlr.TerminalNode | null;
|
|
840
|
+
COMMA(): antlr.TerminalNode[];
|
|
841
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
842
|
+
get ruleIndex(): number;
|
|
843
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
844
|
+
}
|
|
845
|
+
export declare class Create_virtual_table_stmtContext extends antlr.ParserRuleContext {
|
|
846
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
847
|
+
CREATE_(): antlr.TerminalNode;
|
|
848
|
+
VIRTUAL_(): antlr.TerminalNode;
|
|
849
|
+
TABLE_(): antlr.TerminalNode;
|
|
850
|
+
table_name(): Table_nameContext;
|
|
851
|
+
USING_(): antlr.TerminalNode;
|
|
852
|
+
module_name(): Module_nameContext;
|
|
853
|
+
IF_(): antlr.TerminalNode | null;
|
|
854
|
+
NOT_(): antlr.TerminalNode | null;
|
|
855
|
+
EXISTS_(): antlr.TerminalNode | null;
|
|
856
|
+
schema_name(): Schema_nameContext | null;
|
|
857
|
+
DOT(): antlr.TerminalNode | null;
|
|
858
|
+
OPEN_PAR(): antlr.TerminalNode | null;
|
|
859
|
+
module_argument(): Module_argumentContext[];
|
|
860
|
+
module_argument(i: number): Module_argumentContext | null;
|
|
861
|
+
CLOSE_PAR(): antlr.TerminalNode | null;
|
|
862
|
+
COMMA(): antlr.TerminalNode[];
|
|
863
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
864
|
+
get ruleIndex(): number;
|
|
865
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
866
|
+
}
|
|
867
|
+
export declare class With_clauseContext extends antlr.ParserRuleContext {
|
|
868
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
869
|
+
WITH_(): antlr.TerminalNode;
|
|
870
|
+
common_table_expression(): Common_table_expressionContext[];
|
|
871
|
+
common_table_expression(i: number): Common_table_expressionContext | null;
|
|
872
|
+
RECURSIVE_(): antlr.TerminalNode | null;
|
|
873
|
+
COMMA(): antlr.TerminalNode[];
|
|
874
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
875
|
+
get ruleIndex(): number;
|
|
876
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
877
|
+
}
|
|
878
|
+
export declare class Common_table_expressionContext extends antlr.ParserRuleContext {
|
|
879
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
880
|
+
cte_table_name(): Cte_table_nameContext;
|
|
881
|
+
AS_(): antlr.TerminalNode;
|
|
882
|
+
OPEN_PAR(): antlr.TerminalNode;
|
|
883
|
+
select_stmt(): Select_stmtContext;
|
|
884
|
+
CLOSE_PAR(): antlr.TerminalNode;
|
|
885
|
+
MATERIALIZED_(): antlr.TerminalNode | null;
|
|
886
|
+
NOT_(): antlr.TerminalNode | null;
|
|
887
|
+
get ruleIndex(): number;
|
|
888
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
889
|
+
}
|
|
890
|
+
export declare class Cte_table_nameContext extends antlr.ParserRuleContext {
|
|
891
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
892
|
+
table_name(): Table_nameContext;
|
|
893
|
+
OPEN_PAR(): antlr.TerminalNode | null;
|
|
894
|
+
column_name(): Column_nameContext[];
|
|
895
|
+
column_name(i: number): Column_nameContext | null;
|
|
896
|
+
CLOSE_PAR(): antlr.TerminalNode | null;
|
|
897
|
+
COMMA(): antlr.TerminalNode[];
|
|
898
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
899
|
+
get ruleIndex(): number;
|
|
900
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
901
|
+
}
|
|
902
|
+
export declare class Delete_stmtContext extends antlr.ParserRuleContext {
|
|
903
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
904
|
+
DELETE_(): antlr.TerminalNode;
|
|
905
|
+
FROM_(): antlr.TerminalNode;
|
|
906
|
+
qualified_table_name(): Qualified_table_nameContext;
|
|
907
|
+
with_clause(): With_clauseContext | null;
|
|
908
|
+
WHERE_(): antlr.TerminalNode | null;
|
|
909
|
+
expr(): ExprContext | null;
|
|
910
|
+
returning_clause(): Returning_clauseContext | null;
|
|
911
|
+
order_clause(): Order_clauseContext | null;
|
|
912
|
+
limit_clause(): Limit_clauseContext | null;
|
|
913
|
+
get ruleIndex(): number;
|
|
914
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
915
|
+
}
|
|
916
|
+
export declare class Detach_stmtContext extends antlr.ParserRuleContext {
|
|
917
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
918
|
+
DETACH_(): antlr.TerminalNode;
|
|
919
|
+
schema_name(): Schema_nameContext;
|
|
920
|
+
DATABASE_(): antlr.TerminalNode | null;
|
|
921
|
+
get ruleIndex(): number;
|
|
922
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
923
|
+
}
|
|
924
|
+
export declare class Drop_stmtContext extends antlr.ParserRuleContext {
|
|
925
|
+
_object?: Token | null;
|
|
926
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
927
|
+
DROP_(): antlr.TerminalNode;
|
|
928
|
+
any_name(): Any_nameContext;
|
|
929
|
+
INDEX_(): antlr.TerminalNode | null;
|
|
930
|
+
TABLE_(): antlr.TerminalNode | null;
|
|
931
|
+
TRIGGER_(): antlr.TerminalNode | null;
|
|
932
|
+
VIEW_(): antlr.TerminalNode | null;
|
|
933
|
+
IF_(): antlr.TerminalNode | null;
|
|
934
|
+
EXISTS_(): antlr.TerminalNode | null;
|
|
935
|
+
schema_name(): Schema_nameContext | null;
|
|
936
|
+
DOT(): antlr.TerminalNode | null;
|
|
937
|
+
get ruleIndex(): number;
|
|
938
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
939
|
+
}
|
|
940
|
+
export declare class ExprContext extends antlr.ParserRuleContext {
|
|
941
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
942
|
+
expr_or(): Expr_orContext;
|
|
943
|
+
get ruleIndex(): number;
|
|
944
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
945
|
+
}
|
|
946
|
+
export declare class Expr_orContext extends antlr.ParserRuleContext {
|
|
947
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
948
|
+
expr_and(): Expr_andContext[];
|
|
949
|
+
expr_and(i: number): Expr_andContext | null;
|
|
950
|
+
OR_(): antlr.TerminalNode[];
|
|
951
|
+
OR_(i: number): antlr.TerminalNode | null;
|
|
952
|
+
get ruleIndex(): number;
|
|
953
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
954
|
+
}
|
|
955
|
+
export declare class Expr_andContext extends antlr.ParserRuleContext {
|
|
956
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
957
|
+
expr_not(): Expr_notContext[];
|
|
958
|
+
expr_not(i: number): Expr_notContext | null;
|
|
959
|
+
AND_(): antlr.TerminalNode[];
|
|
960
|
+
AND_(i: number): antlr.TerminalNode | null;
|
|
961
|
+
get ruleIndex(): number;
|
|
962
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
963
|
+
}
|
|
964
|
+
export declare class Expr_notContext extends antlr.ParserRuleContext {
|
|
965
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
966
|
+
expr_binary(): Expr_binaryContext;
|
|
967
|
+
NOT_(): antlr.TerminalNode[];
|
|
968
|
+
NOT_(i: number): antlr.TerminalNode | null;
|
|
969
|
+
get ruleIndex(): number;
|
|
970
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
971
|
+
}
|
|
972
|
+
export declare class Expr_binaryContext extends antlr.ParserRuleContext {
|
|
973
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
974
|
+
expr_comparison(): Expr_comparisonContext[];
|
|
975
|
+
expr_comparison(i: number): Expr_comparisonContext | null;
|
|
976
|
+
IS_(): antlr.TerminalNode[];
|
|
977
|
+
IS_(i: number): antlr.TerminalNode | null;
|
|
978
|
+
BETWEEN_(): antlr.TerminalNode[];
|
|
979
|
+
BETWEEN_(i: number): antlr.TerminalNode | null;
|
|
980
|
+
AND_(): antlr.TerminalNode[];
|
|
981
|
+
AND_(i: number): antlr.TerminalNode | null;
|
|
982
|
+
IN_(): antlr.TerminalNode[];
|
|
983
|
+
IN_(i: number): antlr.TerminalNode | null;
|
|
984
|
+
ISNULL_(): antlr.TerminalNode[];
|
|
985
|
+
ISNULL_(i: number): antlr.TerminalNode | null;
|
|
986
|
+
NOTNULL_(): antlr.TerminalNode[];
|
|
987
|
+
NOTNULL_(i: number): antlr.TerminalNode | null;
|
|
988
|
+
NOT_(): antlr.TerminalNode[];
|
|
989
|
+
NOT_(i: number): antlr.TerminalNode | null;
|
|
990
|
+
NULL_(): antlr.TerminalNode[];
|
|
991
|
+
NULL_(i: number): antlr.TerminalNode | null;
|
|
992
|
+
ASSIGN(): antlr.TerminalNode[];
|
|
993
|
+
ASSIGN(i: number): antlr.TerminalNode | null;
|
|
994
|
+
EQ(): antlr.TerminalNode[];
|
|
995
|
+
EQ(i: number): antlr.TerminalNode | null;
|
|
996
|
+
NOT_EQ1(): antlr.TerminalNode[];
|
|
997
|
+
NOT_EQ1(i: number): antlr.TerminalNode | null;
|
|
998
|
+
NOT_EQ2(): antlr.TerminalNode[];
|
|
999
|
+
NOT_EQ2(i: number): antlr.TerminalNode | null;
|
|
1000
|
+
OPEN_PAR(): antlr.TerminalNode[];
|
|
1001
|
+
OPEN_PAR(i: number): antlr.TerminalNode | null;
|
|
1002
|
+
CLOSE_PAR(): antlr.TerminalNode[];
|
|
1003
|
+
CLOSE_PAR(i: number): antlr.TerminalNode | null;
|
|
1004
|
+
table_name(): Table_nameContext[];
|
|
1005
|
+
table_name(i: number): Table_nameContext | null;
|
|
1006
|
+
table_function_name(): Table_function_nameContext[];
|
|
1007
|
+
table_function_name(i: number): Table_function_nameContext | null;
|
|
1008
|
+
LIKE_(): antlr.TerminalNode[];
|
|
1009
|
+
LIKE_(i: number): antlr.TerminalNode | null;
|
|
1010
|
+
DISTINCT_(): antlr.TerminalNode[];
|
|
1011
|
+
DISTINCT_(i: number): antlr.TerminalNode | null;
|
|
1012
|
+
FROM_(): antlr.TerminalNode[];
|
|
1013
|
+
FROM_(i: number): antlr.TerminalNode | null;
|
|
1014
|
+
GLOB_(): antlr.TerminalNode[];
|
|
1015
|
+
GLOB_(i: number): antlr.TerminalNode | null;
|
|
1016
|
+
REGEXP_(): antlr.TerminalNode[];
|
|
1017
|
+
REGEXP_(i: number): antlr.TerminalNode | null;
|
|
1018
|
+
MATCH_(): antlr.TerminalNode[];
|
|
1019
|
+
MATCH_(i: number): antlr.TerminalNode | null;
|
|
1020
|
+
select_stmt(): Select_stmtContext[];
|
|
1021
|
+
select_stmt(i: number): Select_stmtContext | null;
|
|
1022
|
+
schema_name(): Schema_nameContext[];
|
|
1023
|
+
schema_name(i: number): Schema_nameContext | null;
|
|
1024
|
+
DOT(): antlr.TerminalNode[];
|
|
1025
|
+
DOT(i: number): antlr.TerminalNode | null;
|
|
1026
|
+
ESCAPE_(): antlr.TerminalNode[];
|
|
1027
|
+
ESCAPE_(i: number): antlr.TerminalNode | null;
|
|
1028
|
+
COMMA(): antlr.TerminalNode[];
|
|
1029
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
1030
|
+
get ruleIndex(): number;
|
|
1031
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1032
|
+
}
|
|
1033
|
+
export declare class Expr_comparisonContext extends antlr.ParserRuleContext {
|
|
1034
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1035
|
+
expr_bitwise(): Expr_bitwiseContext[];
|
|
1036
|
+
expr_bitwise(i: number): Expr_bitwiseContext | null;
|
|
1037
|
+
LT(): antlr.TerminalNode[];
|
|
1038
|
+
LT(i: number): antlr.TerminalNode | null;
|
|
1039
|
+
LT_EQ(): antlr.TerminalNode[];
|
|
1040
|
+
LT_EQ(i: number): antlr.TerminalNode | null;
|
|
1041
|
+
GT(): antlr.TerminalNode[];
|
|
1042
|
+
GT(i: number): antlr.TerminalNode | null;
|
|
1043
|
+
GT_EQ(): antlr.TerminalNode[];
|
|
1044
|
+
GT_EQ(i: number): antlr.TerminalNode | null;
|
|
1045
|
+
get ruleIndex(): number;
|
|
1046
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1047
|
+
}
|
|
1048
|
+
export declare class Expr_bitwiseContext extends antlr.ParserRuleContext {
|
|
1049
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1050
|
+
expr_addition(): Expr_additionContext[];
|
|
1051
|
+
expr_addition(i: number): Expr_additionContext | null;
|
|
1052
|
+
LT2(): antlr.TerminalNode[];
|
|
1053
|
+
LT2(i: number): antlr.TerminalNode | null;
|
|
1054
|
+
GT2(): antlr.TerminalNode[];
|
|
1055
|
+
GT2(i: number): antlr.TerminalNode | null;
|
|
1056
|
+
AMP(): antlr.TerminalNode[];
|
|
1057
|
+
AMP(i: number): antlr.TerminalNode | null;
|
|
1058
|
+
PIPE(): antlr.TerminalNode[];
|
|
1059
|
+
PIPE(i: number): antlr.TerminalNode | null;
|
|
1060
|
+
get ruleIndex(): number;
|
|
1061
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1062
|
+
}
|
|
1063
|
+
export declare class Expr_additionContext extends antlr.ParserRuleContext {
|
|
1064
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1065
|
+
expr_multiplication(): Expr_multiplicationContext[];
|
|
1066
|
+
expr_multiplication(i: number): Expr_multiplicationContext | null;
|
|
1067
|
+
PLUS(): antlr.TerminalNode[];
|
|
1068
|
+
PLUS(i: number): antlr.TerminalNode | null;
|
|
1069
|
+
MINUS(): antlr.TerminalNode[];
|
|
1070
|
+
MINUS(i: number): antlr.TerminalNode | null;
|
|
1071
|
+
get ruleIndex(): number;
|
|
1072
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1073
|
+
}
|
|
1074
|
+
export declare class Expr_multiplicationContext extends antlr.ParserRuleContext {
|
|
1075
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1076
|
+
expr_string(): Expr_stringContext[];
|
|
1077
|
+
expr_string(i: number): Expr_stringContext | null;
|
|
1078
|
+
STAR(): antlr.TerminalNode[];
|
|
1079
|
+
STAR(i: number): antlr.TerminalNode | null;
|
|
1080
|
+
DIV(): antlr.TerminalNode[];
|
|
1081
|
+
DIV(i: number): antlr.TerminalNode | null;
|
|
1082
|
+
MOD(): antlr.TerminalNode[];
|
|
1083
|
+
MOD(i: number): antlr.TerminalNode | null;
|
|
1084
|
+
get ruleIndex(): number;
|
|
1085
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1086
|
+
}
|
|
1087
|
+
export declare class Expr_stringContext extends antlr.ParserRuleContext {
|
|
1088
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1089
|
+
expr_collate(): Expr_collateContext[];
|
|
1090
|
+
expr_collate(i: number): Expr_collateContext | null;
|
|
1091
|
+
PIPE2(): antlr.TerminalNode[];
|
|
1092
|
+
PIPE2(i: number): antlr.TerminalNode | null;
|
|
1093
|
+
JPTR(): antlr.TerminalNode[];
|
|
1094
|
+
JPTR(i: number): antlr.TerminalNode | null;
|
|
1095
|
+
JPTR2(): antlr.TerminalNode[];
|
|
1096
|
+
JPTR2(i: number): antlr.TerminalNode | null;
|
|
1097
|
+
get ruleIndex(): number;
|
|
1098
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1099
|
+
}
|
|
1100
|
+
export declare class Expr_collateContext extends antlr.ParserRuleContext {
|
|
1101
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1102
|
+
expr_unary(): Expr_unaryContext;
|
|
1103
|
+
COLLATE_(): antlr.TerminalNode[];
|
|
1104
|
+
COLLATE_(i: number): antlr.TerminalNode | null;
|
|
1105
|
+
collation_name(): Collation_nameContext[];
|
|
1106
|
+
collation_name(i: number): Collation_nameContext | null;
|
|
1107
|
+
get ruleIndex(): number;
|
|
1108
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1109
|
+
}
|
|
1110
|
+
export declare class Expr_unaryContext extends antlr.ParserRuleContext {
|
|
1111
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1112
|
+
expr_base(): Expr_baseContext;
|
|
1113
|
+
MINUS(): antlr.TerminalNode[];
|
|
1114
|
+
MINUS(i: number): antlr.TerminalNode | null;
|
|
1115
|
+
PLUS(): antlr.TerminalNode[];
|
|
1116
|
+
PLUS(i: number): antlr.TerminalNode | null;
|
|
1117
|
+
TILDE(): antlr.TerminalNode[];
|
|
1118
|
+
TILDE(i: number): antlr.TerminalNode | null;
|
|
1119
|
+
get ruleIndex(): number;
|
|
1120
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1121
|
+
}
|
|
1122
|
+
export declare class Expr_baseContext extends antlr.ParserRuleContext {
|
|
1123
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1124
|
+
literal_value(): Literal_valueContext | null;
|
|
1125
|
+
BIND_PARAMETER(): antlr.TerminalNode | null;
|
|
1126
|
+
table_name(): Table_nameContext | null;
|
|
1127
|
+
DOT(): antlr.TerminalNode[];
|
|
1128
|
+
DOT(i: number): antlr.TerminalNode | null;
|
|
1129
|
+
column_name(): Column_nameContext | null;
|
|
1130
|
+
schema_name(): Schema_nameContext | null;
|
|
1131
|
+
column_name_excluding_string(): Column_name_excluding_stringContext | null;
|
|
1132
|
+
OPEN_PAR(): antlr.TerminalNode | null;
|
|
1133
|
+
select_stmt(): Select_stmtContext | null;
|
|
1134
|
+
CLOSE_PAR(): antlr.TerminalNode | null;
|
|
1135
|
+
EXISTS_(): antlr.TerminalNode | null;
|
|
1136
|
+
NOT_(): antlr.TerminalNode | null;
|
|
1137
|
+
raise_function(): Raise_functionContext | null;
|
|
1138
|
+
expr_recursive(): Expr_recursiveContext | null;
|
|
1139
|
+
get ruleIndex(): number;
|
|
1140
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1141
|
+
}
|
|
1142
|
+
export declare class Expr_recursiveContext extends antlr.ParserRuleContext {
|
|
1143
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1144
|
+
function_name(): Function_nameContext | null;
|
|
1145
|
+
OPEN_PAR(): antlr.TerminalNode | null;
|
|
1146
|
+
CLOSE_PAR(): antlr.TerminalNode | null;
|
|
1147
|
+
expr(): ExprContext[];
|
|
1148
|
+
expr(i: number): ExprContext | null;
|
|
1149
|
+
STAR(): antlr.TerminalNode | null;
|
|
1150
|
+
percentile_clause(): Percentile_clauseContext | null;
|
|
1151
|
+
filter_clause(): Filter_clauseContext | null;
|
|
1152
|
+
over_clause(): Over_clauseContext | null;
|
|
1153
|
+
DISTINCT_(): antlr.TerminalNode | null;
|
|
1154
|
+
COMMA(): antlr.TerminalNode[];
|
|
1155
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
1156
|
+
order_clause(): Order_clauseContext | null;
|
|
1157
|
+
CAST_(): antlr.TerminalNode | null;
|
|
1158
|
+
AS_(): antlr.TerminalNode | null;
|
|
1159
|
+
type_name(): Type_nameContext | null;
|
|
1160
|
+
CASE_(): antlr.TerminalNode | null;
|
|
1161
|
+
END_(): antlr.TerminalNode | null;
|
|
1162
|
+
WHEN_(): antlr.TerminalNode[];
|
|
1163
|
+
WHEN_(i: number): antlr.TerminalNode | null;
|
|
1164
|
+
THEN_(): antlr.TerminalNode[];
|
|
1165
|
+
THEN_(i: number): antlr.TerminalNode | null;
|
|
1166
|
+
ELSE_(): antlr.TerminalNode | null;
|
|
1167
|
+
get ruleIndex(): number;
|
|
1168
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1169
|
+
}
|
|
1170
|
+
export declare class Raise_functionContext extends antlr.ParserRuleContext {
|
|
1171
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1172
|
+
RAISE_(): antlr.TerminalNode;
|
|
1173
|
+
OPEN_PAR(): antlr.TerminalNode;
|
|
1174
|
+
CLOSE_PAR(): antlr.TerminalNode;
|
|
1175
|
+
IGNORE_(): antlr.TerminalNode | null;
|
|
1176
|
+
COMMA(): antlr.TerminalNode | null;
|
|
1177
|
+
error_message(): Error_messageContext | null;
|
|
1178
|
+
ROLLBACK_(): antlr.TerminalNode | null;
|
|
1179
|
+
ABORT_(): antlr.TerminalNode | null;
|
|
1180
|
+
FAIL_(): antlr.TerminalNode | null;
|
|
1181
|
+
get ruleIndex(): number;
|
|
1182
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1183
|
+
}
|
|
1184
|
+
export declare class Literal_valueContext extends antlr.ParserRuleContext {
|
|
1185
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1186
|
+
NUMERIC_LITERAL(): antlr.TerminalNode | null;
|
|
1187
|
+
STRING_LITERAL(): antlr.TerminalNode | null;
|
|
1188
|
+
BLOB_LITERAL(): antlr.TerminalNode | null;
|
|
1189
|
+
NULL_(): antlr.TerminalNode | null;
|
|
1190
|
+
TRUE_(): antlr.TerminalNode | null;
|
|
1191
|
+
FALSE_(): antlr.TerminalNode | null;
|
|
1192
|
+
CURRENT_TIME_(): antlr.TerminalNode | null;
|
|
1193
|
+
CURRENT_DATE_(): antlr.TerminalNode | null;
|
|
1194
|
+
CURRENT_TIMESTAMP_(): antlr.TerminalNode | null;
|
|
1195
|
+
get ruleIndex(): number;
|
|
1196
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1197
|
+
}
|
|
1198
|
+
export declare class Percentile_clauseContext extends antlr.ParserRuleContext {
|
|
1199
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1200
|
+
WITHIN_(): antlr.TerminalNode;
|
|
1201
|
+
GROUP_(): antlr.TerminalNode;
|
|
1202
|
+
OPEN_PAR(): antlr.TerminalNode;
|
|
1203
|
+
ORDER_(): antlr.TerminalNode;
|
|
1204
|
+
BY_(): antlr.TerminalNode;
|
|
1205
|
+
expr(): ExprContext;
|
|
1206
|
+
CLOSE_PAR(): antlr.TerminalNode;
|
|
1207
|
+
get ruleIndex(): number;
|
|
1208
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1209
|
+
}
|
|
1210
|
+
export declare class Value_rowContext extends antlr.ParserRuleContext {
|
|
1211
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1212
|
+
OPEN_PAR(): antlr.TerminalNode;
|
|
1213
|
+
expr(): ExprContext[];
|
|
1214
|
+
expr(i: number): ExprContext | null;
|
|
1215
|
+
CLOSE_PAR(): antlr.TerminalNode;
|
|
1216
|
+
COMMA(): antlr.TerminalNode[];
|
|
1217
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
1218
|
+
get ruleIndex(): number;
|
|
1219
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1220
|
+
}
|
|
1221
|
+
export declare class Values_clauseContext extends antlr.ParserRuleContext {
|
|
1222
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1223
|
+
VALUES_(): antlr.TerminalNode;
|
|
1224
|
+
value_row(): Value_rowContext[];
|
|
1225
|
+
value_row(i: number): Value_rowContext | null;
|
|
1226
|
+
COMMA(): antlr.TerminalNode[];
|
|
1227
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
1228
|
+
get ruleIndex(): number;
|
|
1229
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1230
|
+
}
|
|
1231
|
+
export declare class Insert_stmtContext extends antlr.ParserRuleContext {
|
|
1232
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1233
|
+
INTO_(): antlr.TerminalNode;
|
|
1234
|
+
table_name(): Table_nameContext;
|
|
1235
|
+
INSERT_(): antlr.TerminalNode | null;
|
|
1236
|
+
REPLACE_(): antlr.TerminalNode | null;
|
|
1237
|
+
OR_(): antlr.TerminalNode | null;
|
|
1238
|
+
select_stmt(): Select_stmtContext | null;
|
|
1239
|
+
DEFAULT_(): antlr.TerminalNode | null;
|
|
1240
|
+
VALUES_(): antlr.TerminalNode | null;
|
|
1241
|
+
with_clause(): With_clauseContext | null;
|
|
1242
|
+
ROLLBACK_(): antlr.TerminalNode | null;
|
|
1243
|
+
ABORT_(): antlr.TerminalNode | null;
|
|
1244
|
+
FAIL_(): antlr.TerminalNode | null;
|
|
1245
|
+
IGNORE_(): antlr.TerminalNode | null;
|
|
1246
|
+
schema_name(): Schema_nameContext | null;
|
|
1247
|
+
DOT(): antlr.TerminalNode | null;
|
|
1248
|
+
AS_(): antlr.TerminalNode | null;
|
|
1249
|
+
table_alias(): Table_aliasContext | null;
|
|
1250
|
+
OPEN_PAR(): antlr.TerminalNode | null;
|
|
1251
|
+
column_name(): Column_nameContext[];
|
|
1252
|
+
column_name(i: number): Column_nameContext | null;
|
|
1253
|
+
CLOSE_PAR(): antlr.TerminalNode | null;
|
|
1254
|
+
returning_clause(): Returning_clauseContext | null;
|
|
1255
|
+
upsert_clause(): Upsert_clauseContext[];
|
|
1256
|
+
upsert_clause(i: number): Upsert_clauseContext | null;
|
|
1257
|
+
COMMA(): antlr.TerminalNode[];
|
|
1258
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
1259
|
+
get ruleIndex(): number;
|
|
1260
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1261
|
+
}
|
|
1262
|
+
export declare class Returning_clauseContext extends antlr.ParserRuleContext {
|
|
1263
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1264
|
+
RETURNING_(): antlr.TerminalNode;
|
|
1265
|
+
STAR(): antlr.TerminalNode[];
|
|
1266
|
+
STAR(i: number): antlr.TerminalNode | null;
|
|
1267
|
+
expr(): ExprContext[];
|
|
1268
|
+
expr(i: number): ExprContext | null;
|
|
1269
|
+
COMMA(): antlr.TerminalNode[];
|
|
1270
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
1271
|
+
column_alias(): Column_aliasContext[];
|
|
1272
|
+
column_alias(i: number): Column_aliasContext | null;
|
|
1273
|
+
AS_(): antlr.TerminalNode[];
|
|
1274
|
+
AS_(i: number): antlr.TerminalNode | null;
|
|
1275
|
+
get ruleIndex(): number;
|
|
1276
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1277
|
+
}
|
|
1278
|
+
export declare class Upsert_clauseContext extends antlr.ParserRuleContext {
|
|
1279
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1280
|
+
ON_(): antlr.TerminalNode;
|
|
1281
|
+
CONFLICT_(): antlr.TerminalNode;
|
|
1282
|
+
DO_(): antlr.TerminalNode;
|
|
1283
|
+
NOTHING_(): antlr.TerminalNode | null;
|
|
1284
|
+
UPDATE_(): antlr.TerminalNode | null;
|
|
1285
|
+
SET_(): antlr.TerminalNode | null;
|
|
1286
|
+
ASSIGN(): antlr.TerminalNode[];
|
|
1287
|
+
ASSIGN(i: number): antlr.TerminalNode | null;
|
|
1288
|
+
expr(): ExprContext[];
|
|
1289
|
+
expr(i: number): ExprContext | null;
|
|
1290
|
+
OPEN_PAR(): antlr.TerminalNode | null;
|
|
1291
|
+
indexed_column(): Indexed_columnContext[];
|
|
1292
|
+
indexed_column(i: number): Indexed_columnContext | null;
|
|
1293
|
+
CLOSE_PAR(): antlr.TerminalNode | null;
|
|
1294
|
+
column_name(): Column_nameContext[];
|
|
1295
|
+
column_name(i: number): Column_nameContext | null;
|
|
1296
|
+
column_name_list(): Column_name_listContext[];
|
|
1297
|
+
column_name_list(i: number): Column_name_listContext | null;
|
|
1298
|
+
COMMA(): antlr.TerminalNode[];
|
|
1299
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
1300
|
+
WHERE_(): antlr.TerminalNode[];
|
|
1301
|
+
WHERE_(i: number): antlr.TerminalNode | null;
|
|
1302
|
+
get ruleIndex(): number;
|
|
1303
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1304
|
+
}
|
|
1305
|
+
export declare class Pragma_stmtContext extends antlr.ParserRuleContext {
|
|
1306
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1307
|
+
PRAGMA_(): antlr.TerminalNode;
|
|
1308
|
+
pragma_name(): Pragma_nameContext;
|
|
1309
|
+
schema_name(): Schema_nameContext | null;
|
|
1310
|
+
DOT(): antlr.TerminalNode | null;
|
|
1311
|
+
ASSIGN(): antlr.TerminalNode | null;
|
|
1312
|
+
pragma_value(): Pragma_valueContext | null;
|
|
1313
|
+
OPEN_PAR(): antlr.TerminalNode | null;
|
|
1314
|
+
CLOSE_PAR(): antlr.TerminalNode | null;
|
|
1315
|
+
get ruleIndex(): number;
|
|
1316
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1317
|
+
}
|
|
1318
|
+
export declare class Pragma_valueContext extends antlr.ParserRuleContext {
|
|
1319
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1320
|
+
signed_number(): Signed_numberContext | null;
|
|
1321
|
+
name(): NameContext | null;
|
|
1322
|
+
STRING_LITERAL(): antlr.TerminalNode | null;
|
|
1323
|
+
get ruleIndex(): number;
|
|
1324
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1325
|
+
}
|
|
1326
|
+
export declare class Reindex_stmtContext extends antlr.ParserRuleContext {
|
|
1327
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1328
|
+
REINDEX_(): antlr.TerminalNode;
|
|
1329
|
+
collation_name(): Collation_nameContext | null;
|
|
1330
|
+
table_name(): Table_nameContext | null;
|
|
1331
|
+
index_name(): Index_nameContext | null;
|
|
1332
|
+
schema_name(): Schema_nameContext | null;
|
|
1333
|
+
DOT(): antlr.TerminalNode | null;
|
|
1334
|
+
get ruleIndex(): number;
|
|
1335
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1336
|
+
}
|
|
1337
|
+
export declare class Select_stmtContext extends antlr.ParserRuleContext {
|
|
1338
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1339
|
+
select_core(): Select_coreContext[];
|
|
1340
|
+
select_core(i: number): Select_coreContext | null;
|
|
1341
|
+
with_clause(): With_clauseContext | null;
|
|
1342
|
+
compound_operator(): Compound_operatorContext[];
|
|
1343
|
+
compound_operator(i: number): Compound_operatorContext | null;
|
|
1344
|
+
order_clause(): Order_clauseContext | null;
|
|
1345
|
+
limit_clause(): Limit_clauseContext | null;
|
|
1346
|
+
get ruleIndex(): number;
|
|
1347
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1348
|
+
}
|
|
1349
|
+
export declare class Join_clauseContext extends antlr.ParserRuleContext {
|
|
1350
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1351
|
+
table_or_subquery(): Table_or_subqueryContext[];
|
|
1352
|
+
table_or_subquery(i: number): Table_or_subqueryContext | null;
|
|
1353
|
+
join_operator(): Join_operatorContext[];
|
|
1354
|
+
join_operator(i: number): Join_operatorContext | null;
|
|
1355
|
+
join_constraint(): Join_constraintContext[];
|
|
1356
|
+
join_constraint(i: number): Join_constraintContext | null;
|
|
1357
|
+
get ruleIndex(): number;
|
|
1358
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1359
|
+
}
|
|
1360
|
+
export declare class Select_coreContext extends antlr.ParserRuleContext {
|
|
1361
|
+
_where_expr?: ExprContext;
|
|
1362
|
+
_expr?: ExprContext;
|
|
1363
|
+
_group_by_expr: ExprContext[];
|
|
1364
|
+
_having_expr?: ExprContext;
|
|
1365
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1366
|
+
SELECT_(): antlr.TerminalNode | null;
|
|
1367
|
+
result_column(): Result_columnContext[];
|
|
1368
|
+
result_column(i: number): Result_columnContext | null;
|
|
1369
|
+
COMMA(): antlr.TerminalNode[];
|
|
1370
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
1371
|
+
FROM_(): antlr.TerminalNode | null;
|
|
1372
|
+
join_clause(): Join_clauseContext | null;
|
|
1373
|
+
WHERE_(): antlr.TerminalNode | null;
|
|
1374
|
+
GROUP_(): antlr.TerminalNode | null;
|
|
1375
|
+
BY_(): antlr.TerminalNode | null;
|
|
1376
|
+
WINDOW_(): antlr.TerminalNode | null;
|
|
1377
|
+
window_name(): Window_nameContext[];
|
|
1378
|
+
window_name(i: number): Window_nameContext | null;
|
|
1379
|
+
AS_(): antlr.TerminalNode[];
|
|
1380
|
+
AS_(i: number): antlr.TerminalNode | null;
|
|
1381
|
+
window_defn(): Window_defnContext[];
|
|
1382
|
+
window_defn(i: number): Window_defnContext | null;
|
|
1383
|
+
DISTINCT_(): antlr.TerminalNode | null;
|
|
1384
|
+
ALL_(): antlr.TerminalNode | null;
|
|
1385
|
+
expr(): ExprContext[];
|
|
1386
|
+
expr(i: number): ExprContext | null;
|
|
1387
|
+
HAVING_(): antlr.TerminalNode | null;
|
|
1388
|
+
values_clause(): Values_clauseContext | null;
|
|
1389
|
+
get ruleIndex(): number;
|
|
1390
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1391
|
+
}
|
|
1392
|
+
export declare class Table_or_subqueryContext extends antlr.ParserRuleContext {
|
|
1393
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1394
|
+
table_name(): Table_nameContext | null;
|
|
1395
|
+
schema_name(): Schema_nameContext | null;
|
|
1396
|
+
DOT(): antlr.TerminalNode | null;
|
|
1397
|
+
AS_(): antlr.TerminalNode | null;
|
|
1398
|
+
table_alias(): Table_aliasContext | null;
|
|
1399
|
+
table_alias_excluding_joins(): Table_alias_excluding_joinsContext | null;
|
|
1400
|
+
INDEXED_(): antlr.TerminalNode | null;
|
|
1401
|
+
BY_(): antlr.TerminalNode | null;
|
|
1402
|
+
index_name(): Index_nameContext | null;
|
|
1403
|
+
NOT_(): antlr.TerminalNode | null;
|
|
1404
|
+
table_function_name(): Table_function_nameContext | null;
|
|
1405
|
+
OPEN_PAR(): antlr.TerminalNode | null;
|
|
1406
|
+
expr(): ExprContext[];
|
|
1407
|
+
expr(i: number): ExprContext | null;
|
|
1408
|
+
CLOSE_PAR(): antlr.TerminalNode | null;
|
|
1409
|
+
COMMA(): antlr.TerminalNode[];
|
|
1410
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
1411
|
+
join_clause(): Join_clauseContext | null;
|
|
1412
|
+
select_stmt(): Select_stmtContext | null;
|
|
1413
|
+
get ruleIndex(): number;
|
|
1414
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1415
|
+
}
|
|
1416
|
+
export declare class Result_columnContext extends antlr.ParserRuleContext {
|
|
1417
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1418
|
+
STAR(): antlr.TerminalNode | null;
|
|
1419
|
+
table_name(): Table_nameContext | null;
|
|
1420
|
+
DOT(): antlr.TerminalNode | null;
|
|
1421
|
+
expr(): ExprContext | null;
|
|
1422
|
+
column_alias(): Column_aliasContext | null;
|
|
1423
|
+
AS_(): antlr.TerminalNode | null;
|
|
1424
|
+
get ruleIndex(): number;
|
|
1425
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1426
|
+
}
|
|
1427
|
+
export declare class Join_operatorContext extends antlr.ParserRuleContext {
|
|
1428
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1429
|
+
COMMA(): antlr.TerminalNode | null;
|
|
1430
|
+
JOIN_(): antlr.TerminalNode | null;
|
|
1431
|
+
NATURAL_(): antlr.TerminalNode | null;
|
|
1432
|
+
INNER_(): antlr.TerminalNode | null;
|
|
1433
|
+
CROSS_(): antlr.TerminalNode | null;
|
|
1434
|
+
LEFT_(): antlr.TerminalNode | null;
|
|
1435
|
+
RIGHT_(): antlr.TerminalNode | null;
|
|
1436
|
+
FULL_(): antlr.TerminalNode | null;
|
|
1437
|
+
OUTER_(): antlr.TerminalNode | null;
|
|
1438
|
+
get ruleIndex(): number;
|
|
1439
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1440
|
+
}
|
|
1441
|
+
export declare class Join_constraintContext extends antlr.ParserRuleContext {
|
|
1442
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1443
|
+
ON_(): antlr.TerminalNode | null;
|
|
1444
|
+
expr(): ExprContext | null;
|
|
1445
|
+
USING_(): antlr.TerminalNode | null;
|
|
1446
|
+
OPEN_PAR(): antlr.TerminalNode | null;
|
|
1447
|
+
column_name(): Column_nameContext[];
|
|
1448
|
+
column_name(i: number): Column_nameContext | null;
|
|
1449
|
+
CLOSE_PAR(): antlr.TerminalNode | null;
|
|
1450
|
+
COMMA(): antlr.TerminalNode[];
|
|
1451
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
1452
|
+
get ruleIndex(): number;
|
|
1453
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1454
|
+
}
|
|
1455
|
+
export declare class Compound_operatorContext extends antlr.ParserRuleContext {
|
|
1456
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1457
|
+
UNION_(): antlr.TerminalNode | null;
|
|
1458
|
+
ALL_(): antlr.TerminalNode | null;
|
|
1459
|
+
INTERSECT_(): antlr.TerminalNode | null;
|
|
1460
|
+
EXCEPT_(): antlr.TerminalNode | null;
|
|
1461
|
+
get ruleIndex(): number;
|
|
1462
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1463
|
+
}
|
|
1464
|
+
export declare class Update_stmtContext extends antlr.ParserRuleContext {
|
|
1465
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1466
|
+
UPDATE_(): antlr.TerminalNode;
|
|
1467
|
+
qualified_table_name(): Qualified_table_nameContext;
|
|
1468
|
+
SET_(): antlr.TerminalNode;
|
|
1469
|
+
ASSIGN(): antlr.TerminalNode[];
|
|
1470
|
+
ASSIGN(i: number): antlr.TerminalNode | null;
|
|
1471
|
+
expr(): ExprContext[];
|
|
1472
|
+
expr(i: number): ExprContext | null;
|
|
1473
|
+
column_name(): Column_nameContext[];
|
|
1474
|
+
column_name(i: number): Column_nameContext | null;
|
|
1475
|
+
column_name_list(): Column_name_listContext[];
|
|
1476
|
+
column_name_list(i: number): Column_name_listContext | null;
|
|
1477
|
+
with_clause(): With_clauseContext | null;
|
|
1478
|
+
OR_(): antlr.TerminalNode | null;
|
|
1479
|
+
COMMA(): antlr.TerminalNode[];
|
|
1480
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
1481
|
+
FROM_(): antlr.TerminalNode | null;
|
|
1482
|
+
join_clause(): Join_clauseContext | null;
|
|
1483
|
+
WHERE_(): antlr.TerminalNode | null;
|
|
1484
|
+
returning_clause(): Returning_clauseContext | null;
|
|
1485
|
+
order_clause(): Order_clauseContext | null;
|
|
1486
|
+
limit_clause(): Limit_clauseContext | null;
|
|
1487
|
+
ROLLBACK_(): antlr.TerminalNode | null;
|
|
1488
|
+
ABORT_(): antlr.TerminalNode | null;
|
|
1489
|
+
REPLACE_(): antlr.TerminalNode | null;
|
|
1490
|
+
FAIL_(): antlr.TerminalNode | null;
|
|
1491
|
+
IGNORE_(): antlr.TerminalNode | null;
|
|
1492
|
+
get ruleIndex(): number;
|
|
1493
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1494
|
+
}
|
|
1495
|
+
export declare class Column_name_listContext extends antlr.ParserRuleContext {
|
|
1496
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1497
|
+
OPEN_PAR(): antlr.TerminalNode;
|
|
1498
|
+
column_name(): Column_nameContext[];
|
|
1499
|
+
column_name(i: number): Column_nameContext | null;
|
|
1500
|
+
CLOSE_PAR(): antlr.TerminalNode;
|
|
1501
|
+
COMMA(): antlr.TerminalNode[];
|
|
1502
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
1503
|
+
get ruleIndex(): number;
|
|
1504
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1505
|
+
}
|
|
1506
|
+
export declare class Qualified_table_nameContext extends antlr.ParserRuleContext {
|
|
1507
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1508
|
+
table_name(): Table_nameContext;
|
|
1509
|
+
schema_name(): Schema_nameContext | null;
|
|
1510
|
+
DOT(): antlr.TerminalNode | null;
|
|
1511
|
+
AS_(): antlr.TerminalNode | null;
|
|
1512
|
+
alias(): AliasContext | null;
|
|
1513
|
+
INDEXED_(): antlr.TerminalNode | null;
|
|
1514
|
+
BY_(): antlr.TerminalNode | null;
|
|
1515
|
+
index_name(): Index_nameContext | null;
|
|
1516
|
+
NOT_(): antlr.TerminalNode | null;
|
|
1517
|
+
get ruleIndex(): number;
|
|
1518
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1519
|
+
}
|
|
1520
|
+
export declare class Vacuum_stmtContext extends antlr.ParserRuleContext {
|
|
1521
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1522
|
+
VACUUM_(): antlr.TerminalNode;
|
|
1523
|
+
schema_name(): Schema_nameContext | null;
|
|
1524
|
+
INTO_(): antlr.TerminalNode | null;
|
|
1525
|
+
filename(): FilenameContext | null;
|
|
1526
|
+
get ruleIndex(): number;
|
|
1527
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1528
|
+
}
|
|
1529
|
+
export declare class Filter_clauseContext extends antlr.ParserRuleContext {
|
|
1530
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1531
|
+
FILTER_(): antlr.TerminalNode;
|
|
1532
|
+
OPEN_PAR(): antlr.TerminalNode;
|
|
1533
|
+
WHERE_(): antlr.TerminalNode;
|
|
1534
|
+
expr(): ExprContext;
|
|
1535
|
+
CLOSE_PAR(): antlr.TerminalNode;
|
|
1536
|
+
get ruleIndex(): number;
|
|
1537
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1538
|
+
}
|
|
1539
|
+
export declare class Window_defnContext extends antlr.ParserRuleContext {
|
|
1540
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1541
|
+
OPEN_PAR(): antlr.TerminalNode;
|
|
1542
|
+
CLOSE_PAR(): antlr.TerminalNode;
|
|
1543
|
+
base_window_name(): Base_window_nameContext | null;
|
|
1544
|
+
PARTITION_(): antlr.TerminalNode | null;
|
|
1545
|
+
BY_(): antlr.TerminalNode | null;
|
|
1546
|
+
expr(): ExprContext[];
|
|
1547
|
+
expr(i: number): ExprContext | null;
|
|
1548
|
+
order_clause(): Order_clauseContext | null;
|
|
1549
|
+
frame_spec(): Frame_specContext | null;
|
|
1550
|
+
COMMA(): antlr.TerminalNode[];
|
|
1551
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
1552
|
+
get ruleIndex(): number;
|
|
1553
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1554
|
+
}
|
|
1555
|
+
export declare class Over_clauseContext extends antlr.ParserRuleContext {
|
|
1556
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1557
|
+
OVER_(): antlr.TerminalNode;
|
|
1558
|
+
window_name(): Window_nameContext | null;
|
|
1559
|
+
OPEN_PAR(): antlr.TerminalNode | null;
|
|
1560
|
+
CLOSE_PAR(): antlr.TerminalNode | null;
|
|
1561
|
+
base_window_name(): Base_window_nameContext | null;
|
|
1562
|
+
PARTITION_(): antlr.TerminalNode | null;
|
|
1563
|
+
BY_(): antlr.TerminalNode | null;
|
|
1564
|
+
expr(): ExprContext[];
|
|
1565
|
+
expr(i: number): ExprContext | null;
|
|
1566
|
+
order_clause(): Order_clauseContext | null;
|
|
1567
|
+
frame_spec(): Frame_specContext | null;
|
|
1568
|
+
COMMA(): antlr.TerminalNode[];
|
|
1569
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
1570
|
+
get ruleIndex(): number;
|
|
1571
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1572
|
+
}
|
|
1573
|
+
export declare class Frame_specContext extends antlr.ParserRuleContext {
|
|
1574
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1575
|
+
frame_clause(): Frame_clauseContext;
|
|
1576
|
+
EXCLUDE_(): antlr.TerminalNode | null;
|
|
1577
|
+
NO_(): antlr.TerminalNode | null;
|
|
1578
|
+
OTHERS_(): antlr.TerminalNode | null;
|
|
1579
|
+
CURRENT_(): antlr.TerminalNode | null;
|
|
1580
|
+
ROW_(): antlr.TerminalNode | null;
|
|
1581
|
+
GROUP_(): antlr.TerminalNode | null;
|
|
1582
|
+
TIES_(): antlr.TerminalNode | null;
|
|
1583
|
+
get ruleIndex(): number;
|
|
1584
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1585
|
+
}
|
|
1586
|
+
export declare class Frame_clauseContext extends antlr.ParserRuleContext {
|
|
1587
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1588
|
+
RANGE_(): antlr.TerminalNode | null;
|
|
1589
|
+
ROWS_(): antlr.TerminalNode | null;
|
|
1590
|
+
GROUPS_(): antlr.TerminalNode | null;
|
|
1591
|
+
frame_single(): Frame_singleContext | null;
|
|
1592
|
+
BETWEEN_(): antlr.TerminalNode | null;
|
|
1593
|
+
frame_left(): Frame_leftContext | null;
|
|
1594
|
+
AND_(): antlr.TerminalNode | null;
|
|
1595
|
+
frame_right(): Frame_rightContext | null;
|
|
1596
|
+
get ruleIndex(): number;
|
|
1597
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1598
|
+
}
|
|
1599
|
+
export declare class Order_clauseContext extends antlr.ParserRuleContext {
|
|
1600
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1601
|
+
ORDER_(): antlr.TerminalNode;
|
|
1602
|
+
BY_(): antlr.TerminalNode;
|
|
1603
|
+
ordering_term(): Ordering_termContext[];
|
|
1604
|
+
ordering_term(i: number): Ordering_termContext | null;
|
|
1605
|
+
COMMA(): antlr.TerminalNode[];
|
|
1606
|
+
COMMA(i: number): antlr.TerminalNode | null;
|
|
1607
|
+
get ruleIndex(): number;
|
|
1608
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1609
|
+
}
|
|
1610
|
+
export declare class Limit_clauseContext extends antlr.ParserRuleContext {
|
|
1611
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1612
|
+
LIMIT_(): antlr.TerminalNode;
|
|
1613
|
+
expr(): ExprContext[];
|
|
1614
|
+
expr(i: number): ExprContext | null;
|
|
1615
|
+
OFFSET_(): antlr.TerminalNode | null;
|
|
1616
|
+
COMMA(): antlr.TerminalNode | null;
|
|
1617
|
+
get ruleIndex(): number;
|
|
1618
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1619
|
+
}
|
|
1620
|
+
export declare class Ordering_termContext extends antlr.ParserRuleContext {
|
|
1621
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1622
|
+
expr(): ExprContext;
|
|
1623
|
+
COLLATE_(): antlr.TerminalNode | null;
|
|
1624
|
+
collation_name(): Collation_nameContext | null;
|
|
1625
|
+
asc_desc(): Asc_descContext | null;
|
|
1626
|
+
NULLS_(): antlr.TerminalNode | null;
|
|
1627
|
+
FIRST_(): antlr.TerminalNode | null;
|
|
1628
|
+
LAST_(): antlr.TerminalNode | null;
|
|
1629
|
+
get ruleIndex(): number;
|
|
1630
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1631
|
+
}
|
|
1632
|
+
export declare class Asc_descContext extends antlr.ParserRuleContext {
|
|
1633
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1634
|
+
ASC_(): antlr.TerminalNode | null;
|
|
1635
|
+
DESC_(): antlr.TerminalNode | null;
|
|
1636
|
+
get ruleIndex(): number;
|
|
1637
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1638
|
+
}
|
|
1639
|
+
export declare class Frame_leftContext extends antlr.ParserRuleContext {
|
|
1640
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1641
|
+
expr(): ExprContext | null;
|
|
1642
|
+
PRECEDING_(): antlr.TerminalNode | null;
|
|
1643
|
+
FOLLOWING_(): antlr.TerminalNode | null;
|
|
1644
|
+
CURRENT_(): antlr.TerminalNode | null;
|
|
1645
|
+
ROW_(): antlr.TerminalNode | null;
|
|
1646
|
+
get ruleIndex(): number;
|
|
1647
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1648
|
+
}
|
|
1649
|
+
export declare class Frame_rightContext extends antlr.ParserRuleContext {
|
|
1650
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1651
|
+
expr(): ExprContext | null;
|
|
1652
|
+
PRECEDING_(): antlr.TerminalNode | null;
|
|
1653
|
+
FOLLOWING_(): antlr.TerminalNode | null;
|
|
1654
|
+
CURRENT_(): antlr.TerminalNode | null;
|
|
1655
|
+
ROW_(): antlr.TerminalNode | null;
|
|
1656
|
+
get ruleIndex(): number;
|
|
1657
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1658
|
+
}
|
|
1659
|
+
export declare class Frame_singleContext extends antlr.ParserRuleContext {
|
|
1660
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1661
|
+
expr(): ExprContext | null;
|
|
1662
|
+
PRECEDING_(): antlr.TerminalNode | null;
|
|
1663
|
+
CURRENT_(): antlr.TerminalNode | null;
|
|
1664
|
+
ROW_(): antlr.TerminalNode | null;
|
|
1665
|
+
get ruleIndex(): number;
|
|
1666
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1667
|
+
}
|
|
1668
|
+
export declare class Error_messageContext extends antlr.ParserRuleContext {
|
|
1669
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1670
|
+
expr(): ExprContext;
|
|
1671
|
+
get ruleIndex(): number;
|
|
1672
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1673
|
+
}
|
|
1674
|
+
export declare class FilenameContext extends antlr.ParserRuleContext {
|
|
1675
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1676
|
+
expr(): ExprContext;
|
|
1677
|
+
get ruleIndex(): number;
|
|
1678
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1679
|
+
}
|
|
1680
|
+
export declare class Module_argumentContext extends antlr.ParserRuleContext {
|
|
1681
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1682
|
+
module_argument_outer(): Module_argument_outerContext[];
|
|
1683
|
+
module_argument_outer(i: number): Module_argument_outerContext | null;
|
|
1684
|
+
get ruleIndex(): number;
|
|
1685
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1686
|
+
}
|
|
1687
|
+
export declare class Module_argument_outerContext extends antlr.ParserRuleContext {
|
|
1688
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1689
|
+
OPEN_PAR(): antlr.TerminalNode | null;
|
|
1690
|
+
CLOSE_PAR(): antlr.TerminalNode | null;
|
|
1691
|
+
UNEXPECTED_CHAR(): antlr.TerminalNode | null;
|
|
1692
|
+
COMMA(): antlr.TerminalNode | null;
|
|
1693
|
+
module_argument_inner(): Module_argument_innerContext[];
|
|
1694
|
+
module_argument_inner(i: number): Module_argument_innerContext | null;
|
|
1695
|
+
get ruleIndex(): number;
|
|
1696
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1697
|
+
}
|
|
1698
|
+
export declare class Module_argument_innerContext extends antlr.ParserRuleContext {
|
|
1699
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1700
|
+
OPEN_PAR(): antlr.TerminalNode | null;
|
|
1701
|
+
CLOSE_PAR(): antlr.TerminalNode | null;
|
|
1702
|
+
UNEXPECTED_CHAR(): antlr.TerminalNode | null;
|
|
1703
|
+
module_argument_inner(): Module_argument_innerContext[];
|
|
1704
|
+
module_argument_inner(i: number): Module_argument_innerContext | null;
|
|
1705
|
+
get ruleIndex(): number;
|
|
1706
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1707
|
+
}
|
|
1708
|
+
export declare class Fallback_excluding_conflictsContext extends antlr.ParserRuleContext {
|
|
1709
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1710
|
+
ABORT_(): antlr.TerminalNode | null;
|
|
1711
|
+
ACTION_(): antlr.TerminalNode | null;
|
|
1712
|
+
AFTER_(): antlr.TerminalNode | null;
|
|
1713
|
+
ALWAYS_(): antlr.TerminalNode | null;
|
|
1714
|
+
ANALYZE_(): antlr.TerminalNode | null;
|
|
1715
|
+
ASC_(): antlr.TerminalNode | null;
|
|
1716
|
+
ATTACH_(): antlr.TerminalNode | null;
|
|
1717
|
+
BEFORE_(): antlr.TerminalNode | null;
|
|
1718
|
+
BEGIN_(): antlr.TerminalNode | null;
|
|
1719
|
+
BY_(): antlr.TerminalNode | null;
|
|
1720
|
+
CASCADE_(): antlr.TerminalNode | null;
|
|
1721
|
+
CAST_(): antlr.TerminalNode | null;
|
|
1722
|
+
COLUMN_(): antlr.TerminalNode | null;
|
|
1723
|
+
CONFLICT_(): antlr.TerminalNode | null;
|
|
1724
|
+
CURRENT_(): antlr.TerminalNode | null;
|
|
1725
|
+
CURRENT_DATE_(): antlr.TerminalNode | null;
|
|
1726
|
+
CURRENT_TIME_(): antlr.TerminalNode | null;
|
|
1727
|
+
CURRENT_TIMESTAMP_(): antlr.TerminalNode | null;
|
|
1728
|
+
DATABASE_(): antlr.TerminalNode | null;
|
|
1729
|
+
DEFERRED_(): antlr.TerminalNode | null;
|
|
1730
|
+
DESC_(): antlr.TerminalNode | null;
|
|
1731
|
+
DETACH_(): antlr.TerminalNode | null;
|
|
1732
|
+
DO_(): antlr.TerminalNode | null;
|
|
1733
|
+
EACH_(): antlr.TerminalNode | null;
|
|
1734
|
+
END_(): antlr.TerminalNode | null;
|
|
1735
|
+
EXCEPT_(): antlr.TerminalNode | null;
|
|
1736
|
+
EXCLUDE_(): antlr.TerminalNode | null;
|
|
1737
|
+
EXCLUSIVE_(): antlr.TerminalNode | null;
|
|
1738
|
+
EXPLAIN_(): antlr.TerminalNode | null;
|
|
1739
|
+
FAIL_(): antlr.TerminalNode | null;
|
|
1740
|
+
FALSE_(): antlr.TerminalNode | null;
|
|
1741
|
+
FIRST_(): antlr.TerminalNode | null;
|
|
1742
|
+
FOLLOWING_(): antlr.TerminalNode | null;
|
|
1743
|
+
FOR_(): antlr.TerminalNode | null;
|
|
1744
|
+
GENERATED_(): antlr.TerminalNode | null;
|
|
1745
|
+
GLOB_(): antlr.TerminalNode | null;
|
|
1746
|
+
GROUPS_(): antlr.TerminalNode | null;
|
|
1747
|
+
IF_(): antlr.TerminalNode | null;
|
|
1748
|
+
IGNORE_(): antlr.TerminalNode | null;
|
|
1749
|
+
IMMEDIATE_(): antlr.TerminalNode | null;
|
|
1750
|
+
INITIALLY_(): antlr.TerminalNode | null;
|
|
1751
|
+
INSTEAD_(): antlr.TerminalNode | null;
|
|
1752
|
+
INTERSECT_(): antlr.TerminalNode | null;
|
|
1753
|
+
KEY_(): antlr.TerminalNode | null;
|
|
1754
|
+
LAST_(): antlr.TerminalNode | null;
|
|
1755
|
+
LIKE_(): antlr.TerminalNode | null;
|
|
1756
|
+
MATCH_(): antlr.TerminalNode | null;
|
|
1757
|
+
MATERIALIZED_(): antlr.TerminalNode | null;
|
|
1758
|
+
NO_(): antlr.TerminalNode | null;
|
|
1759
|
+
NULLS_(): antlr.TerminalNode | null;
|
|
1760
|
+
OF_(): antlr.TerminalNode | null;
|
|
1761
|
+
OFFSET_(): antlr.TerminalNode | null;
|
|
1762
|
+
OTHERS_(): antlr.TerminalNode | null;
|
|
1763
|
+
PARTITION_(): antlr.TerminalNode | null;
|
|
1764
|
+
PLAN_(): antlr.TerminalNode | null;
|
|
1765
|
+
PRAGMA_(): antlr.TerminalNode | null;
|
|
1766
|
+
PRECEDING_(): antlr.TerminalNode | null;
|
|
1767
|
+
QUERY_(): antlr.TerminalNode | null;
|
|
1768
|
+
RANGE_(): antlr.TerminalNode | null;
|
|
1769
|
+
RECURSIVE_(): antlr.TerminalNode | null;
|
|
1770
|
+
REGEXP_(): antlr.TerminalNode | null;
|
|
1771
|
+
REINDEX_(): antlr.TerminalNode | null;
|
|
1772
|
+
RELEASE_(): antlr.TerminalNode | null;
|
|
1773
|
+
RENAME_(): antlr.TerminalNode | null;
|
|
1774
|
+
REPLACE_(): antlr.TerminalNode | null;
|
|
1775
|
+
RESTRICT_(): antlr.TerminalNode | null;
|
|
1776
|
+
ROLLBACK_(): antlr.TerminalNode | null;
|
|
1777
|
+
ROW_(): antlr.TerminalNode | null;
|
|
1778
|
+
ROWID_(): antlr.TerminalNode | null;
|
|
1779
|
+
ROWS_(): antlr.TerminalNode | null;
|
|
1780
|
+
SAVEPOINT_(): antlr.TerminalNode | null;
|
|
1781
|
+
STORED_(): antlr.TerminalNode | null;
|
|
1782
|
+
STRICT_(): antlr.TerminalNode | null;
|
|
1783
|
+
TEMP_(): antlr.TerminalNode | null;
|
|
1784
|
+
TEMPORARY_(): antlr.TerminalNode | null;
|
|
1785
|
+
TIES_(): antlr.TerminalNode | null;
|
|
1786
|
+
TRIGGER_(): antlr.TerminalNode | null;
|
|
1787
|
+
TRUE_(): antlr.TerminalNode | null;
|
|
1788
|
+
UNBOUNDED_(): antlr.TerminalNode | null;
|
|
1789
|
+
UNION_(): antlr.TerminalNode | null;
|
|
1790
|
+
VACUUM_(): antlr.TerminalNode | null;
|
|
1791
|
+
VIEW_(): antlr.TerminalNode | null;
|
|
1792
|
+
VIRTUAL_(): antlr.TerminalNode | null;
|
|
1793
|
+
WITH_(): antlr.TerminalNode | null;
|
|
1794
|
+
WITHIN_(): antlr.TerminalNode | null;
|
|
1795
|
+
WITHOUT_(): antlr.TerminalNode | null;
|
|
1796
|
+
get ruleIndex(): number;
|
|
1797
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1798
|
+
}
|
|
1799
|
+
export declare class Join_keywordContext extends antlr.ParserRuleContext {
|
|
1800
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1801
|
+
CROSS_(): antlr.TerminalNode | null;
|
|
1802
|
+
FULL_(): antlr.TerminalNode | null;
|
|
1803
|
+
INDEXED_(): antlr.TerminalNode | null;
|
|
1804
|
+
INNER_(): antlr.TerminalNode | null;
|
|
1805
|
+
LEFT_(): antlr.TerminalNode | null;
|
|
1806
|
+
NATURAL_(): antlr.TerminalNode | null;
|
|
1807
|
+
OUTER_(): antlr.TerminalNode | null;
|
|
1808
|
+
RIGHT_(): antlr.TerminalNode | null;
|
|
1809
|
+
get ruleIndex(): number;
|
|
1810
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1811
|
+
}
|
|
1812
|
+
export declare class FallbackContext extends antlr.ParserRuleContext {
|
|
1813
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1814
|
+
fallback_excluding_conflicts(): Fallback_excluding_conflictsContext | null;
|
|
1815
|
+
join_keyword(): Join_keywordContext | null;
|
|
1816
|
+
RAISE_(): antlr.TerminalNode | null;
|
|
1817
|
+
get ruleIndex(): number;
|
|
1818
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1819
|
+
}
|
|
1820
|
+
export declare class NameContext extends antlr.ParserRuleContext {
|
|
1821
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1822
|
+
any_name(): Any_nameContext;
|
|
1823
|
+
get ruleIndex(): number;
|
|
1824
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1825
|
+
}
|
|
1826
|
+
export declare class Function_nameContext extends antlr.ParserRuleContext {
|
|
1827
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1828
|
+
any_name_excluding_raise(): Any_name_excluding_raiseContext;
|
|
1829
|
+
get ruleIndex(): number;
|
|
1830
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1831
|
+
}
|
|
1832
|
+
export declare class Schema_nameContext extends antlr.ParserRuleContext {
|
|
1833
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1834
|
+
any_name(): Any_nameContext;
|
|
1835
|
+
get ruleIndex(): number;
|
|
1836
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1837
|
+
}
|
|
1838
|
+
export declare class Table_nameContext extends antlr.ParserRuleContext {
|
|
1839
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1840
|
+
any_name(): Any_nameContext;
|
|
1841
|
+
get ruleIndex(): number;
|
|
1842
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1843
|
+
}
|
|
1844
|
+
export declare class Table_or_index_nameContext extends antlr.ParserRuleContext {
|
|
1845
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1846
|
+
any_name(): Any_nameContext;
|
|
1847
|
+
get ruleIndex(): number;
|
|
1848
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1849
|
+
}
|
|
1850
|
+
export declare class Column_nameContext extends antlr.ParserRuleContext {
|
|
1851
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1852
|
+
any_name(): Any_nameContext;
|
|
1853
|
+
get ruleIndex(): number;
|
|
1854
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1855
|
+
}
|
|
1856
|
+
export declare class Column_name_excluding_stringContext extends antlr.ParserRuleContext {
|
|
1857
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1858
|
+
any_name_excluding_string(): Any_name_excluding_stringContext;
|
|
1859
|
+
get ruleIndex(): number;
|
|
1860
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1861
|
+
}
|
|
1862
|
+
export declare class Column_aliasContext extends antlr.ParserRuleContext {
|
|
1863
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1864
|
+
any_name(): Any_nameContext;
|
|
1865
|
+
get ruleIndex(): number;
|
|
1866
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1867
|
+
}
|
|
1868
|
+
export declare class Collation_nameContext extends antlr.ParserRuleContext {
|
|
1869
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1870
|
+
any_name(): Any_nameContext;
|
|
1871
|
+
get ruleIndex(): number;
|
|
1872
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1873
|
+
}
|
|
1874
|
+
export declare class Foreign_tableContext extends antlr.ParserRuleContext {
|
|
1875
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1876
|
+
any_name(): Any_nameContext;
|
|
1877
|
+
get ruleIndex(): number;
|
|
1878
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1879
|
+
}
|
|
1880
|
+
export declare class Index_nameContext extends antlr.ParserRuleContext {
|
|
1881
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1882
|
+
any_name(): Any_nameContext;
|
|
1883
|
+
get ruleIndex(): number;
|
|
1884
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1885
|
+
}
|
|
1886
|
+
export declare class Trigger_nameContext extends antlr.ParserRuleContext {
|
|
1887
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1888
|
+
any_name(): Any_nameContext;
|
|
1889
|
+
get ruleIndex(): number;
|
|
1890
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1891
|
+
}
|
|
1892
|
+
export declare class View_nameContext extends antlr.ParserRuleContext {
|
|
1893
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1894
|
+
any_name(): Any_nameContext;
|
|
1895
|
+
get ruleIndex(): number;
|
|
1896
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1897
|
+
}
|
|
1898
|
+
export declare class Module_nameContext extends antlr.ParserRuleContext {
|
|
1899
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1900
|
+
any_name(): Any_nameContext;
|
|
1901
|
+
get ruleIndex(): number;
|
|
1902
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1903
|
+
}
|
|
1904
|
+
export declare class Pragma_nameContext extends antlr.ParserRuleContext {
|
|
1905
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1906
|
+
any_name(): Any_nameContext;
|
|
1907
|
+
get ruleIndex(): number;
|
|
1908
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1909
|
+
}
|
|
1910
|
+
export declare class Savepoint_nameContext extends antlr.ParserRuleContext {
|
|
1911
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1912
|
+
any_name(): Any_nameContext;
|
|
1913
|
+
get ruleIndex(): number;
|
|
1914
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1915
|
+
}
|
|
1916
|
+
export declare class Table_aliasContext extends antlr.ParserRuleContext {
|
|
1917
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1918
|
+
any_name(): Any_nameContext;
|
|
1919
|
+
get ruleIndex(): number;
|
|
1920
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1921
|
+
}
|
|
1922
|
+
export declare class Table_alias_excluding_joinsContext extends antlr.ParserRuleContext {
|
|
1923
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1924
|
+
any_name_excluding_joins(): Any_name_excluding_joinsContext;
|
|
1925
|
+
get ruleIndex(): number;
|
|
1926
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1927
|
+
}
|
|
1928
|
+
export declare class Window_nameContext extends antlr.ParserRuleContext {
|
|
1929
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1930
|
+
any_name(): Any_nameContext;
|
|
1931
|
+
get ruleIndex(): number;
|
|
1932
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1933
|
+
}
|
|
1934
|
+
export declare class AliasContext extends antlr.ParserRuleContext {
|
|
1935
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1936
|
+
any_name(): Any_nameContext;
|
|
1937
|
+
get ruleIndex(): number;
|
|
1938
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1939
|
+
}
|
|
1940
|
+
export declare class Base_window_nameContext extends antlr.ParserRuleContext {
|
|
1941
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1942
|
+
any_name(): Any_nameContext;
|
|
1943
|
+
get ruleIndex(): number;
|
|
1944
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1945
|
+
}
|
|
1946
|
+
export declare class Table_function_nameContext extends antlr.ParserRuleContext {
|
|
1947
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1948
|
+
any_name(): Any_nameContext;
|
|
1949
|
+
get ruleIndex(): number;
|
|
1950
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1951
|
+
}
|
|
1952
|
+
export declare class Any_name_excluding_raiseContext extends antlr.ParserRuleContext {
|
|
1953
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1954
|
+
IDENTIFIER(): antlr.TerminalNode | null;
|
|
1955
|
+
fallback_excluding_conflicts(): Fallback_excluding_conflictsContext | null;
|
|
1956
|
+
join_keyword(): Join_keywordContext | null;
|
|
1957
|
+
STRING_LITERAL(): antlr.TerminalNode | null;
|
|
1958
|
+
get ruleIndex(): number;
|
|
1959
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1960
|
+
}
|
|
1961
|
+
export declare class Any_name_excluding_joinsContext extends antlr.ParserRuleContext {
|
|
1962
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1963
|
+
IDENTIFIER(): antlr.TerminalNode | null;
|
|
1964
|
+
fallback_excluding_conflicts(): Fallback_excluding_conflictsContext | null;
|
|
1965
|
+
RAISE_(): antlr.TerminalNode | null;
|
|
1966
|
+
STRING_LITERAL(): antlr.TerminalNode | null;
|
|
1967
|
+
get ruleIndex(): number;
|
|
1968
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1969
|
+
}
|
|
1970
|
+
export declare class Any_name_excluding_stringContext extends antlr.ParserRuleContext {
|
|
1971
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1972
|
+
IDENTIFIER(): antlr.TerminalNode | null;
|
|
1973
|
+
fallback(): FallbackContext | null;
|
|
1974
|
+
get ruleIndex(): number;
|
|
1975
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1976
|
+
}
|
|
1977
|
+
export declare class Any_nameContext extends antlr.ParserRuleContext {
|
|
1978
|
+
constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
|
|
1979
|
+
IDENTIFIER(): antlr.TerminalNode | null;
|
|
1980
|
+
fallback(): FallbackContext | null;
|
|
1981
|
+
STRING_LITERAL(): antlr.TerminalNode | null;
|
|
1982
|
+
get ruleIndex(): number;
|
|
1983
|
+
accept<Result>(visitor: SQLiteParserVisitor<Result>): Result | null;
|
|
1984
|
+
}
|
|
1985
|
+
//# sourceMappingURL=SQLiteParser.d.ts.map
|