@webda/ql 4.0.0-beta.5 → 4.0.0-beta.6

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.
Files changed (55) hide show
  1. package/README.md +68 -27
  2. package/lib/WebdaQLLexer.d.ts +44 -30
  3. package/lib/WebdaQLLexer.d.ts.map +1 -1
  4. package/lib/WebdaQLLexer.js +257 -152
  5. package/lib/WebdaQLLexer.js.map +1 -1
  6. package/lib/WebdaQLParserLexer.d.ts +44 -30
  7. package/lib/WebdaQLParserLexer.d.ts.map +1 -1
  8. package/lib/WebdaQLParserLexer.js +257 -152
  9. package/lib/WebdaQLParserLexer.js.map +1 -1
  10. package/lib/WebdaQLParserListener.d.ts +203 -30
  11. package/lib/WebdaQLParserListener.d.ts.map +1 -1
  12. package/lib/WebdaQLParserParser.d.ts +242 -44
  13. package/lib/WebdaQLParserParser.d.ts.map +1 -1
  14. package/lib/WebdaQLParserParser.js +2054 -715
  15. package/lib/WebdaQLParserParser.js.map +1 -1
  16. package/lib/WebdaQLParserVisitor.d.ts +126 -17
  17. package/lib/WebdaQLParserVisitor.d.ts.map +1 -1
  18. package/lib/aggregation-query.d.ts +95 -0
  19. package/lib/aggregation-query.d.ts.map +1 -0
  20. package/lib/aggregation-query.js +104 -0
  21. package/lib/aggregation-query.js.map +1 -0
  22. package/lib/aggregation-select.spec.d.ts +2 -0
  23. package/lib/aggregation-select.spec.d.ts.map +1 -0
  24. package/lib/aggregation-select.spec.js +164 -0
  25. package/lib/aggregation-select.spec.js.map +1 -0
  26. package/lib/aggregation.d.ts +97 -0
  27. package/lib/aggregation.d.ts.map +1 -0
  28. package/lib/aggregation.js +241 -0
  29. package/lib/aggregation.js.map +1 -0
  30. package/lib/aggregation.spec.d.ts +2 -0
  31. package/lib/aggregation.spec.d.ts.map +1 -0
  32. package/lib/aggregation.spec.js +360 -0
  33. package/lib/aggregation.spec.js.map +1 -0
  34. package/lib/bind.d.ts.map +1 -1
  35. package/lib/bind.js +29 -0
  36. package/lib/bind.js.map +1 -1
  37. package/lib/index.d.ts +1 -0
  38. package/lib/index.d.ts.map +1 -1
  39. package/lib/index.js +1 -0
  40. package/lib/index.js.map +1 -1
  41. package/lib/query.d.ts +162 -8
  42. package/lib/query.d.ts.map +1 -1
  43. package/lib/query.js +489 -45
  44. package/lib/query.js.map +1 -1
  45. package/lib/query.spec.js +6 -4
  46. package/lib/query.spec.js.map +1 -1
  47. package/lib/statements.spec.d.ts +2 -0
  48. package/lib/statements.spec.d.ts.map +1 -0
  49. package/lib/statements.spec.js +422 -0
  50. package/lib/statements.spec.js.map +1 -0
  51. package/lib/webdaql-string.d.ts +9 -0
  52. package/lib/webdaql-string.d.ts.map +1 -1
  53. package/lib/webdaql-string.js +9 -8
  54. package/lib/webdaql-string.js.map +1 -1
  55. package/package.json +2 -2
package/lib/WebdaQLParserParser.js CHANGED
@@ -19,54 +19,90 @@ export class WebdaQLParserParser extends Parser {
19
19
  static DOUBLE_QUOTE_SYMB = 6;
20
20
  static LR_SQ_BRACKET = 7;
21
21
  static RR_SQ_BRACKET = 8;
22
- static AND = 9;
23
- static OR = 10;
24
- static EQUAL = 11;
25
- static NOT_EQUAL = 12;
26
- static GREATER = 13;
27
- static GREATER_OR_EQUAL = 14;
28
- static LESS = 15;
29
- static LESS_OR_EQUAL = 16;
30
- static LIKE = 17;
31
- static IN = 18;
32
- static CONTAINS = 19;
33
- static IS = 20;
34
- static NOT = 21;
35
- static NULL = 22;
36
- static TRUE = 23;
37
- static FALSE = 24;
38
- static LIMIT = 25;
39
- static OFFSET = 26;
40
- static ORDER_BY = 27;
41
- static ASC = 28;
42
- static DESC = 29;
43
- static DQUOTED_STRING_LITERAL = 30;
44
- static SQUOTED_STRING_LITERAL = 31;
45
- static INTEGER_LITERAL = 32;
46
- static NUMBER_LITERAL = 33;
47
- static POSITIONAL_PARAMETER = 34;
48
- static NAMED_PARAMETER = 35;
49
- static IDENTIFIER = 36;
50
- static IDENTIFIER_WITH_NUMBER = 37;
51
- static FUNCTION_IDENTIFIER_WITH_UNDERSCORE = 38;
22
+ static DELETE = 9;
23
+ static UPDATE = 10;
24
+ static SELECT = 11;
25
+ static SET = 12;
26
+ static WHERE = 13;
27
+ static AND = 14;
28
+ static OR = 15;
29
+ static EQUAL = 16;
30
+ static NOT_EQUAL = 17;
31
+ static GREATER = 18;
32
+ static GREATER_OR_EQUAL = 19;
33
+ static LESS = 20;
34
+ static LESS_OR_EQUAL = 21;
35
+ static LIKE = 22;
36
+ static IN = 23;
37
+ static CONTAINS = 24;
38
+ static IS = 25;
39
+ static NOT = 26;
40
+ static NULL = 27;
41
+ static TRUE = 28;
42
+ static FALSE = 29;
43
+ static LIMIT = 30;
44
+ static OFFSET = 31;
45
+ static ORDER_BY = 32;
46
+ static ASC = 33;
47
+ static DESC = 34;
48
+ static GROUP_BY = 35;
49
+ static AS = 36;
50
+ static DISTINCT = 37;
51
+ static COUNT = 38;
52
+ static SUM = 39;
53
+ static AVG = 40;
54
+ static MIN = 41;
55
+ static MAX = 42;
56
+ static STAR = 43;
57
+ static DQUOTED_STRING_LITERAL = 44;
58
+ static SQUOTED_STRING_LITERAL = 45;
59
+ static INTEGER_LITERAL = 46;
60
+ static NUMBER_LITERAL = 47;
61
+ static POSITIONAL_PARAMETER = 48;
62
+ static NAMED_PARAMETER = 49;
63
+ static IDENTIFIER = 50;
64
+ static IDENTIFIER_WITH_NUMBER = 51;
65
+ static FUNCTION_IDENTIFIER_WITH_UNDERSCORE = 52;
52
66
  static RULE_webdaql = 0;
53
- static RULE_limitExpression = 1;
54
- static RULE_offsetExpression = 2;
55
- static RULE_orderFieldExpression = 3;
56
- static RULE_orderExpression = 4;
57
- static RULE_expression = 5;
58
- static RULE_values = 6;
59
- static RULE_atom = 7;
60
- static RULE_identifier = 8;
61
- static RULE_booleanLiteral = 9;
62
- static RULE_stringLiteral = 10;
63
- static RULE_integerLiteral = 11;
64
- static RULE_numberLiteral = 12;
65
- static RULE_parameter = 13;
66
- static RULE_setExpression = 14;
67
+ static RULE_statement = 1;
68
+ static RULE_deleteStatement = 2;
69
+ static RULE_updateStatement = 3;
70
+ static RULE_selectStatement = 4;
71
+ static RULE_filterQuery = 5;
72
+ static RULE_whereClause = 6;
73
+ static RULE_assignmentList = 7;
74
+ static RULE_assignment = 8;
75
+ static RULE_fieldList = 9;
76
+ static RULE_selectItem = 10;
77
+ static RULE_groupByExpression = 11;
78
+ static RULE_limitExpression = 12;
79
+ static RULE_offsetExpression = 13;
80
+ static RULE_orderFieldExpression = 14;
81
+ static RULE_orderExpression = 15;
82
+ static RULE_expression = 16;
83
+ static RULE_values = 17;
84
+ static RULE_atom = 18;
85
+ static RULE_identifier = 19;
86
+ static RULE_booleanLiteral = 20;
87
+ static RULE_stringLiteral = 21;
88
+ static RULE_integerLiteral = 22;
89
+ static RULE_numberLiteral = 23;
90
+ static RULE_parameter = 24;
91
+ static RULE_setExpression = 25;
67
92
  // tslint:disable:no-trailing-whitespace
68
93
  static ruleNames = [
69
94
  "webdaql",
95
+ "statement",
96
+ "deleteStatement",
97
+ "updateStatement",
98
+ "selectStatement",
99
+ "filterQuery",
100
+ "whereClause",
101
+ "assignmentList",
102
+ "assignment",
103
+ "fieldList",
104
+ "selectItem",
105
+ "groupByExpression",
70
106
  "limitExpression",
71
107
  "offsetExpression",
72
108
  "orderFieldExpression",
@@ -92,6 +128,11 @@ export class WebdaQLParserParser extends Parser {
92
128
  "'\"'",
93
129
  "'['",
94
130
  "']'",
131
+ "'DELETE'",
132
+ "'UPDATE'",
133
+ "'SELECT'",
134
+ "'SET'",
135
+ "'WHERE'",
95
136
  "'AND'",
96
137
  "'OR'",
97
138
  "'='",
@@ -113,6 +154,15 @@ export class WebdaQLParserParser extends Parser {
113
154
  "'ORDER BY'",
114
155
  "'ASC'",
115
156
  "'DESC'",
157
+ "'GROUP BY'",
158
+ "'AS'",
159
+ "'DISTINCT'",
160
+ "'COUNT'",
161
+ "'SUM'",
162
+ "'AVG'",
163
+ "'MIN'",
164
+ "'MAX'",
165
+ "'*'",
116
166
  undefined,
117
167
  undefined,
118
168
  undefined,
@@ -129,6 +179,11 @@ export class WebdaQLParserParser extends Parser {
129
179
  "DOUBLE_QUOTE_SYMB",
130
180
  "LR_SQ_BRACKET",
131
181
  "RR_SQ_BRACKET",
182
+ "DELETE",
183
+ "UPDATE",
184
+ "SELECT",
185
+ "SET",
186
+ "WHERE",
132
187
  "AND",
133
188
  "OR",
134
189
  "EQUAL",
@@ -150,6 +205,15 @@ export class WebdaQLParserParser extends Parser {
150
205
  "ORDER_BY",
151
206
  "ASC",
152
207
  "DESC",
208
+ "GROUP_BY",
209
+ "AS",
210
+ "DISTINCT",
211
+ "COUNT",
212
+ "SUM",
213
+ "AVG",
214
+ "MIN",
215
+ "MAX",
216
+ "STAR",
153
217
  "DQUOTED_STRING_LITERAL",
154
218
  "SQUOTED_STRING_LITERAL",
155
219
  "INTEGER_LITERAL",
@@ -190,62 +254,136 @@ export class WebdaQLParserParser extends Parser {
190
254
  webdaql() {
191
255
  let _localctx = new WebdaqlContext(this._ctx, this.state);
192
256
  this.enterRule(_localctx, 0, WebdaQLParserParser.RULE_webdaql);
193
- let _la;
194
257
  try {
195
258
  this.enterOuterAlt(_localctx, 1);
196
259
  {
197
- this.state = 31;
260
+ this.state = 54;
198
261
  this._errHandler.sync(this);
199
- _la = this._input.LA(1);
200
- if (((_la & ~0x1f) === 0 &&
201
- ((1 << _la) &
202
- ((1 << WebdaQLParserParser.LR_BRACKET) |
203
- (1 << WebdaQLParserParser.TRUE) |
204
- (1 << WebdaQLParserParser.FALSE) |
205
- (1 << WebdaQLParserParser.DQUOTED_STRING_LITERAL) |
206
- (1 << WebdaQLParserParser.SQUOTED_STRING_LITERAL))) !==
207
- 0) ||
208
- (((_la - 32) & ~0x1f) === 0 &&
209
- ((1 << (_la - 32)) &
210
- ((1 << (WebdaQLParserParser.INTEGER_LITERAL - 32)) |
211
- (1 << (WebdaQLParserParser.NUMBER_LITERAL - 32)) |
212
- (1 << (WebdaQLParserParser.IDENTIFIER - 32)) |
213
- (1 << (WebdaQLParserParser.IDENTIFIER_WITH_NUMBER - 32)))) !==
214
- 0)) {
262
+ switch (this._input.LA(1)) {
263
+ case WebdaQLParserParser.DELETE:
264
+ case WebdaQLParserParser.UPDATE:
265
+ case WebdaQLParserParser.SELECT:
266
+ {
267
+ this.state = 52;
268
+ this.statement();
269
+ }
270
+ break;
271
+ case WebdaQLParserParser.EOF:
272
+ case WebdaQLParserParser.LR_BRACKET:
273
+ case WebdaQLParserParser.TRUE:
274
+ case WebdaQLParserParser.FALSE:
275
+ case WebdaQLParserParser.LIMIT:
276
+ case WebdaQLParserParser.OFFSET:
277
+ case WebdaQLParserParser.ORDER_BY:
278
+ case WebdaQLParserParser.DQUOTED_STRING_LITERAL:
279
+ case WebdaQLParserParser.SQUOTED_STRING_LITERAL:
280
+ case WebdaQLParserParser.INTEGER_LITERAL:
281
+ case WebdaQLParserParser.NUMBER_LITERAL:
282
+ case WebdaQLParserParser.IDENTIFIER:
283
+ case WebdaQLParserParser.IDENTIFIER_WITH_NUMBER:
284
+ {
285
+ this.state = 53;
286
+ this.filterQuery();
287
+ }
288
+ break;
289
+ default:
290
+ throw new NoViableAltException(this);
291
+ }
292
+ this.state = 56;
293
+ this.match(WebdaQLParserParser.EOF);
294
+ }
295
+ }
296
+ catch (re) {
297
+ if (re instanceof RecognitionException) {
298
+ _localctx.exception = re;
299
+ this._errHandler.reportError(this, re);
300
+ this._errHandler.recover(this, re);
301
+ }
302
+ else {
303
+ throw re;
304
+ }
305
+ }
306
+ finally {
307
+ this.exitRule();
308
+ }
309
+ return _localctx;
310
+ }
311
+ // @RuleVersion(0)
312
+ statement() {
313
+ let _localctx = new StatementContext(this._ctx, this.state);
314
+ this.enterRule(_localctx, 2, WebdaQLParserParser.RULE_statement);
315
+ try {
316
+ this.state = 61;
317
+ this._errHandler.sync(this);
318
+ switch (this._input.LA(1)) {
319
+ case WebdaQLParserParser.DELETE:
320
+ this.enterOuterAlt(_localctx, 1);
215
321
  {
216
- this.state = 30;
217
- this.expression(0);
322
+ this.state = 58;
323
+ this.deleteStatement();
218
324
  }
219
- }
220
- this.state = 34;
221
- this._errHandler.sync(this);
222
- _la = this._input.LA(1);
223
- if (_la === WebdaQLParserParser.ORDER_BY) {
325
+ break;
326
+ case WebdaQLParserParser.UPDATE:
327
+ this.enterOuterAlt(_localctx, 2);
224
328
  {
225
- this.state = 33;
226
- this.orderExpression();
329
+ this.state = 59;
330
+ this.updateStatement();
227
331
  }
228
- }
229
- this.state = 37;
332
+ break;
333
+ case WebdaQLParserParser.SELECT:
334
+ this.enterOuterAlt(_localctx, 3);
335
+ {
336
+ this.state = 60;
337
+ this.selectStatement();
338
+ }
339
+ break;
340
+ default:
341
+ throw new NoViableAltException(this);
342
+ }
343
+ }
344
+ catch (re) {
345
+ if (re instanceof RecognitionException) {
346
+ _localctx.exception = re;
347
+ this._errHandler.reportError(this, re);
348
+ this._errHandler.recover(this, re);
349
+ }
350
+ else {
351
+ throw re;
352
+ }
353
+ }
354
+ finally {
355
+ this.exitRule();
356
+ }
357
+ return _localctx;
358
+ }
359
+ // @RuleVersion(0)
360
+ deleteStatement() {
361
+ let _localctx = new DeleteStatementContext(this._ctx, this.state);
362
+ this.enterRule(_localctx, 4, WebdaQLParserParser.RULE_deleteStatement);
363
+ let _la;
364
+ try {
365
+ this.enterOuterAlt(_localctx, 1);
366
+ {
367
+ this.state = 63;
368
+ this.match(WebdaQLParserParser.DELETE);
369
+ this.state = 65;
230
370
  this._errHandler.sync(this);
231
371
  _la = this._input.LA(1);
232
- if (_la === WebdaQLParserParser.LIMIT) {
372
+ if (_la === WebdaQLParserParser.WHERE) {
233
373
  {
234
- this.state = 36;
235
- this.limitExpression();
374
+ this.state = 64;
375
+ this.whereClause();
236
376
  }
237
377
  }
238
- this.state = 40;
378
+ this.state = 68;
239
379
  this._errHandler.sync(this);
240
380
  _la = this._input.LA(1);
241
- if (_la === WebdaQLParserParser.OFFSET) {
381
+ if (_la === WebdaQLParserParser.LIMIT) {
242
382
  {
243
- this.state = 39;
244
- this.offsetExpression();
383
+ this.state = 67;
384
+ this.limitExpression();
245
385
  }
246
386
  }
247
- this.state = 42;
248
- this.match(WebdaQLParserParser.EOF);
249
387
  }
250
388
  }
251
389
  catch (re) {
@@ -264,32 +402,36 @@ export class WebdaQLParserParser extends Parser {
264
402
  return _localctx;
265
403
  }
266
404
  // @RuleVersion(0)
267
- limitExpression() {
268
- let _localctx = new LimitExpressionContext(this._ctx, this.state);
269
- this.enterRule(_localctx, 2, WebdaQLParserParser.RULE_limitExpression);
405
+ updateStatement() {
406
+ let _localctx = new UpdateStatementContext(this._ctx, this.state);
407
+ this.enterRule(_localctx, 6, WebdaQLParserParser.RULE_updateStatement);
408
+ let _la;
270
409
  try {
271
410
  this.enterOuterAlt(_localctx, 1);
272
411
  {
273
- this.state = 44;
274
- this.match(WebdaQLParserParser.LIMIT);
275
- this.state = 47;
412
+ this.state = 70;
413
+ this.match(WebdaQLParserParser.UPDATE);
414
+ this.state = 71;
415
+ this.match(WebdaQLParserParser.SET);
416
+ this.state = 72;
417
+ this.assignmentList();
418
+ this.state = 74;
276
419
  this._errHandler.sync(this);
277
- switch (this._input.LA(1)) {
278
- case WebdaQLParserParser.INTEGER_LITERAL:
279
- {
280
- this.state = 45;
281
- this.integerLiteral();
282
- }
283
- break;
284
- case WebdaQLParserParser.POSITIONAL_PARAMETER:
285
- case WebdaQLParserParser.NAMED_PARAMETER:
286
- {
287
- this.state = 46;
288
- this.parameter();
289
- }
290
- break;
291
- default:
292
- throw new NoViableAltException(this);
420
+ _la = this._input.LA(1);
421
+ if (_la === WebdaQLParserParser.WHERE) {
422
+ {
423
+ this.state = 73;
424
+ this.whereClause();
425
+ }
426
+ }
427
+ this.state = 77;
428
+ this._errHandler.sync(this);
429
+ _la = this._input.LA(1);
430
+ if (_la === WebdaQLParserParser.LIMIT) {
431
+ {
432
+ this.state = 76;
433
+ this.limitExpression();
434
+ }
293
435
  }
294
436
  }
295
437
  }
@@ -309,33 +451,61 @@ export class WebdaQLParserParser extends Parser {
309
451
  return _localctx;
310
452
  }
311
453
  // @RuleVersion(0)
312
- offsetExpression() {
313
- let _localctx = new OffsetExpressionContext(this._ctx, this.state);
314
- this.enterRule(_localctx, 4, WebdaQLParserParser.RULE_offsetExpression);
454
+ selectStatement() {
455
+ let _localctx = new SelectStatementContext(this._ctx, this.state);
456
+ this.enterRule(_localctx, 8, WebdaQLParserParser.RULE_selectStatement);
457
+ let _la;
315
458
  try {
316
459
  this.enterOuterAlt(_localctx, 1);
317
460
  {
318
- this.state = 49;
319
- this.match(WebdaQLParserParser.OFFSET);
320
- this.state = 52;
461
+ this.state = 79;
462
+ this.match(WebdaQLParserParser.SELECT);
463
+ this.state = 80;
464
+ this.fieldList();
465
+ this.state = 82;
321
466
  this._errHandler.sync(this);
322
- switch (this._input.LA(1)) {
323
- case WebdaQLParserParser.DQUOTED_STRING_LITERAL:
324
- case WebdaQLParserParser.SQUOTED_STRING_LITERAL:
325
- {
326
- this.state = 50;
327
- this.stringLiteral();
328
- }
329
- break;
330
- case WebdaQLParserParser.POSITIONAL_PARAMETER:
331
- case WebdaQLParserParser.NAMED_PARAMETER:
332
- {
333
- this.state = 51;
334
- this.parameter();
335
- }
336
- break;
337
- default:
338
- throw new NoViableAltException(this);
467
+ _la = this._input.LA(1);
468
+ if (_la === WebdaQLParserParser.WHERE) {
469
+ {
470
+ this.state = 81;
471
+ this.whereClause();
472
+ }
473
+ }
474
+ this.state = 85;
475
+ this._errHandler.sync(this);
476
+ _la = this._input.LA(1);
477
+ if (_la === WebdaQLParserParser.GROUP_BY) {
478
+ {
479
+ this.state = 84;
480
+ this.groupByExpression();
481
+ }
482
+ }
483
+ this.state = 88;
484
+ this._errHandler.sync(this);
485
+ _la = this._input.LA(1);
486
+ if (_la === WebdaQLParserParser.ORDER_BY) {
487
+ {
488
+ this.state = 87;
489
+ this.orderExpression();
490
+ }
491
+ }
492
+ this.state = 91;
493
+ this._errHandler.sync(this);
494
+ _la = this._input.LA(1);
495
+ if (_la === WebdaQLParserParser.LIMIT) {
496
+ {
497
+ this.state = 90;
498
+ this.limitExpression();
499
+ }
500
+ }
501
+ this.state = 94;
502
+ this._errHandler.sync(this);
503
+ _la = this._input.LA(1);
504
+ if (_la === WebdaQLParserParser.OFFSET) {
505
+ {
506
+ this.state = 93;
507
+ this.offsetExpression();
508
+ }
339
509
  }
340
510
  }
341
511
  }
@@ -355,32 +525,61 @@ export class WebdaQLParserParser extends Parser {
355
525
  return _localctx;
356
526
  }
357
527
  // @RuleVersion(0)
358
- orderFieldExpression() {
359
- let _localctx = new OrderFieldExpressionContext(this._ctx, this.state);
360
- this.enterRule(_localctx, 6, WebdaQLParserParser.RULE_orderFieldExpression);
528
+ filterQuery() {
529
+ let _localctx = new FilterQueryContext(this._ctx, this.state);
530
+ this.enterRule(_localctx, 10, WebdaQLParserParser.RULE_filterQuery);
361
531
  let _la;
362
532
  try {
363
533
  this.enterOuterAlt(_localctx, 1);
364
534
  {
365
- this.state = 54;
366
- this.identifier();
367
- this.state = 56;
535
+ this.state = 97;
368
536
  this._errHandler.sync(this);
369
537
  _la = this._input.LA(1);
370
- if (_la === WebdaQLParserParser.ASC || _la === WebdaQLParserParser.DESC) {
538
+ if (((_la & ~0x1f) === 0 &&
539
+ ((1 << _la) &
540
+ ((1 << WebdaQLParserParser.LR_BRACKET) |
541
+ (1 << WebdaQLParserParser.TRUE) |
542
+ (1 << WebdaQLParserParser.FALSE))) !==
543
+ 0) ||
544
+ (((_la - 44) & ~0x1f) === 0 &&
545
+ ((1 << (_la - 44)) &
546
+ ((1 << (WebdaQLParserParser.DQUOTED_STRING_LITERAL - 44)) |
547
+ (1 << (WebdaQLParserParser.SQUOTED_STRING_LITERAL - 44)) |
548
+ (1 << (WebdaQLParserParser.INTEGER_LITERAL - 44)) |
549
+ (1 << (WebdaQLParserParser.NUMBER_LITERAL - 44)) |
550
+ (1 << (WebdaQLParserParser.IDENTIFIER - 44)) |
551
+ (1 << (WebdaQLParserParser.IDENTIFIER_WITH_NUMBER - 44)))) !==
552
+ 0)) {
371
553
  {
372
- this.state = 55;
373
- _la = this._input.LA(1);
374
- if (!(_la === WebdaQLParserParser.ASC || _la === WebdaQLParserParser.DESC)) {
375
- this._errHandler.recoverInline(this);
376
- }
377
- else {
378
- if (this._input.LA(1) === Token.EOF) {
379
- this.matchedEOF = true;
380
- }
381
- this._errHandler.reportMatch(this);
382
- this.consume();
383
- }
554
+ this.state = 96;
555
+ this.expression(0);
556
+ }
557
+ }
558
+ this.state = 100;
559
+ this._errHandler.sync(this);
560
+ _la = this._input.LA(1);
561
+ if (_la === WebdaQLParserParser.ORDER_BY) {
562
+ {
563
+ this.state = 99;
564
+ this.orderExpression();
565
+ }
566
+ }
567
+ this.state = 103;
568
+ this._errHandler.sync(this);
569
+ _la = this._input.LA(1);
570
+ if (_la === WebdaQLParserParser.LIMIT) {
571
+ {
572
+ this.state = 102;
573
+ this.limitExpression();
574
+ }
575
+ }
576
+ this.state = 106;
577
+ this._errHandler.sync(this);
578
+ _la = this._input.LA(1);
579
+ if (_la === WebdaQLParserParser.OFFSET) {
580
+ {
581
+ this.state = 105;
582
+ this.offsetExpression();
384
583
  }
385
584
  }
386
585
  }
@@ -401,30 +600,56 @@ export class WebdaQLParserParser extends Parser {
401
600
  return _localctx;
402
601
  }
403
602
  // @RuleVersion(0)
404
- orderExpression() {
405
- let _localctx = new OrderExpressionContext(this._ctx, this.state);
406
- this.enterRule(_localctx, 8, WebdaQLParserParser.RULE_orderExpression);
603
+ whereClause() {
604
+ let _localctx = new WhereClauseContext(this._ctx, this.state);
605
+ this.enterRule(_localctx, 12, WebdaQLParserParser.RULE_whereClause);
606
+ try {
607
+ this.enterOuterAlt(_localctx, 1);
608
+ {
609
+ this.state = 108;
610
+ this.match(WebdaQLParserParser.WHERE);
611
+ this.state = 109;
612
+ this.expression(0);
613
+ }
614
+ }
615
+ catch (re) {
616
+ if (re instanceof RecognitionException) {
617
+ _localctx.exception = re;
618
+ this._errHandler.reportError(this, re);
619
+ this._errHandler.recover(this, re);
620
+ }
621
+ else {
622
+ throw re;
623
+ }
624
+ }
625
+ finally {
626
+ this.exitRule();
627
+ }
628
+ return _localctx;
629
+ }
630
+ // @RuleVersion(0)
631
+ assignmentList() {
632
+ let _localctx = new AssignmentListContext(this._ctx, this.state);
633
+ this.enterRule(_localctx, 14, WebdaQLParserParser.RULE_assignmentList);
407
634
  let _la;
408
635
  try {
409
636
  this.enterOuterAlt(_localctx, 1);
410
637
  {
411
- this.state = 58;
412
- this.match(WebdaQLParserParser.ORDER_BY);
413
- this.state = 59;
414
- this.orderFieldExpression();
415
- this.state = 64;
638
+ this.state = 111;
639
+ this.assignment();
640
+ this.state = 116;
416
641
  this._errHandler.sync(this);
417
642
  _la = this._input.LA(1);
418
643
  while (_la === WebdaQLParserParser.COMMA) {
419
644
  {
420
645
  {
421
- this.state = 60;
646
+ this.state = 112;
422
647
  this.match(WebdaQLParserParser.COMMA);
423
- this.state = 61;
424
- this.orderFieldExpression();
648
+ this.state = 113;
649
+ this.assignment();
425
650
  }
426
651
  }
427
- this.state = 66;
652
+ this.state = 118;
428
653
  this._errHandler.sync(this);
429
654
  _la = this._input.LA(1);
430
655
  }
@@ -446,268 +671,82 @@ export class WebdaQLParserParser extends Parser {
446
671
  return _localctx;
447
672
  }
448
673
  // @RuleVersion(0)
449
- expression(_p) {
450
- if (_p === undefined) {
451
- _p = 0;
452
- }
453
- let _parentctx = this._ctx;
454
- let _parentState = this.state;
455
- let _localctx = new ExpressionContext(this._ctx, _parentState);
456
- let _prevctx = _localctx;
457
- let _startState = 10;
458
- this.enterRecursionRule(_localctx, 10, WebdaQLParserParser.RULE_expression, _p);
459
- let _la;
674
+ assignment() {
675
+ let _localctx = new AssignmentContext(this._ctx, this.state);
676
+ this.enterRule(_localctx, 16, WebdaQLParserParser.RULE_assignment);
460
677
  try {
461
- let _alt;
462
678
  this.enterOuterAlt(_localctx, 1);
463
679
  {
464
- this.state = 106;
680
+ this.state = 119;
681
+ this.identifier();
682
+ this.state = 120;
683
+ this.match(WebdaQLParserParser.EQUAL);
684
+ this.state = 123;
465
685
  this._errHandler.sync(this);
466
- switch (this.interpreter.adaptivePredict(this._input, 12, this._ctx)) {
467
- case 1:
468
- {
469
- _localctx = new LikeExpressionContext(_localctx);
470
- this._ctx = _localctx;
471
- _prevctx = _localctx;
472
- this.state = 68;
473
- this.identifier();
474
- this.state = 69;
475
- this.match(WebdaQLParserParser.LIKE);
476
- this.state = 72;
477
- this._errHandler.sync(this);
478
- switch (this._input.LA(1)) {
479
- case WebdaQLParserParser.DQUOTED_STRING_LITERAL:
480
- case WebdaQLParserParser.SQUOTED_STRING_LITERAL:
481
- {
482
- this.state = 70;
483
- this.stringLiteral();
484
- }
485
- break;
486
- case WebdaQLParserParser.POSITIONAL_PARAMETER:
487
- case WebdaQLParserParser.NAMED_PARAMETER:
488
- {
489
- this.state = 71;
490
- this.parameter();
491
- }
492
- break;
493
- default:
494
- throw new NoViableAltException(this);
495
- }
496
- }
497
- break;
498
- case 2:
499
- {
500
- _localctx = new InExpressionContext(_localctx);
501
- this._ctx = _localctx;
502
- _prevctx = _localctx;
503
- this.state = 74;
504
- this.identifier();
505
- this.state = 75;
506
- this.match(WebdaQLParserParser.IN);
507
- this.state = 78;
508
- this._errHandler.sync(this);
509
- switch (this._input.LA(1)) {
510
- case WebdaQLParserParser.LR_SQ_BRACKET:
511
- {
512
- this.state = 76;
513
- this.setExpression();
514
- }
515
- break;
516
- case WebdaQLParserParser.POSITIONAL_PARAMETER:
517
- case WebdaQLParserParser.NAMED_PARAMETER:
518
- {
519
- this.state = 77;
520
- this.parameter();
521
- }
522
- break;
523
- default:
524
- throw new NoViableAltException(this);
525
- }
526
- }
527
- break;
528
- case 3:
529
- {
530
- _localctx = new ContainsExpressionContext(_localctx);
531
- this._ctx = _localctx;
532
- _prevctx = _localctx;
533
- this.state = 80;
534
- this.identifier();
535
- this.state = 81;
536
- this.match(WebdaQLParserParser.CONTAINS);
537
- this.state = 84;
538
- this._errHandler.sync(this);
539
- switch (this._input.LA(1)) {
540
- case WebdaQLParserParser.DQUOTED_STRING_LITERAL:
541
- case WebdaQLParserParser.SQUOTED_STRING_LITERAL:
542
- {
543
- this.state = 82;
544
- this.stringLiteral();
545
- }
546
- break;
547
- case WebdaQLParserParser.POSITIONAL_PARAMETER:
548
- case WebdaQLParserParser.NAMED_PARAMETER:
549
- {
550
- this.state = 83;
551
- this.parameter();
552
- }
553
- break;
554
- default:
555
- throw new NoViableAltException(this);
556
- }
557
- }
558
- break;
559
- case 4:
560
- {
561
- _localctx = new IsNullExpressionContext(_localctx);
562
- this._ctx = _localctx;
563
- _prevctx = _localctx;
564
- this.state = 86;
565
- this.identifier();
566
- this.state = 87;
567
- this.match(WebdaQLParserParser.IS);
568
- this.state = 88;
569
- this.match(WebdaQLParserParser.NULL);
570
- }
571
- break;
572
- case 5:
573
- {
574
- _localctx = new IsNotNullExpressionContext(_localctx);
575
- this._ctx = _localctx;
576
- _prevctx = _localctx;
577
- this.state = 90;
578
- this.identifier();
579
- this.state = 91;
580
- this.match(WebdaQLParserParser.IS);
581
- this.state = 92;
582
- this.match(WebdaQLParserParser.NOT);
583
- this.state = 93;
584
- this.match(WebdaQLParserParser.NULL);
585
- }
586
- break;
587
- case 6:
588
- {
589
- _localctx = new BinaryComparisonExpressionContext(_localctx);
590
- this._ctx = _localctx;
591
- _prevctx = _localctx;
592
- this.state = 95;
593
- this.identifier();
594
- this.state = 96;
595
- _la = this._input.LA(1);
596
- if (!((_la & ~0x1f) === 0 &&
597
- ((1 << _la) &
598
- ((1 << WebdaQLParserParser.EQUAL) |
599
- (1 << WebdaQLParserParser.NOT_EQUAL) |
600
- (1 << WebdaQLParserParser.GREATER) |
601
- (1 << WebdaQLParserParser.GREATER_OR_EQUAL) |
602
- (1 << WebdaQLParserParser.LESS) |
603
- (1 << WebdaQLParserParser.LESS_OR_EQUAL))) !==
604
- 0)) {
605
- this._errHandler.recoverInline(this);
606
- }
607
- else {
608
- if (this._input.LA(1) === Token.EOF) {
609
- this.matchedEOF = true;
610
- }
611
- this._errHandler.reportMatch(this);
612
- this.consume();
613
- }
614
- this.state = 99;
615
- this._errHandler.sync(this);
616
- switch (this._input.LA(1)) {
617
- case WebdaQLParserParser.TRUE:
618
- case WebdaQLParserParser.FALSE:
619
- case WebdaQLParserParser.DQUOTED_STRING_LITERAL:
620
- case WebdaQLParserParser.SQUOTED_STRING_LITERAL:
621
- case WebdaQLParserParser.INTEGER_LITERAL:
622
- case WebdaQLParserParser.NUMBER_LITERAL:
623
- {
624
- this.state = 97;
625
- this.values();
626
- }
627
- break;
628
- case WebdaQLParserParser.POSITIONAL_PARAMETER:
629
- case WebdaQLParserParser.NAMED_PARAMETER:
630
- {
631
- this.state = 98;
632
- this.parameter();
633
- }
634
- break;
635
- default:
636
- throw new NoViableAltException(this);
637
- }
638
- }
639
- break;
640
- case 7:
686
+ switch (this._input.LA(1)) {
687
+ case WebdaQLParserParser.TRUE:
688
+ case WebdaQLParserParser.FALSE:
689
+ case WebdaQLParserParser.DQUOTED_STRING_LITERAL:
690
+ case WebdaQLParserParser.SQUOTED_STRING_LITERAL:
691
+ case WebdaQLParserParser.INTEGER_LITERAL:
692
+ case WebdaQLParserParser.NUMBER_LITERAL:
641
693
  {
642
- _localctx = new SubExpressionContext(_localctx);
643
- this._ctx = _localctx;
644
- _prevctx = _localctx;
645
- this.state = 101;
646
- this.match(WebdaQLParserParser.LR_BRACKET);
647
- this.state = 102;
648
- this.expression(0);
649
- this.state = 103;
650
- this.match(WebdaQLParserParser.RR_BRACKET);
694
+ this.state = 121;
695
+ this.values();
651
696
  }
652
697
  break;
653
- case 8:
698
+ case WebdaQLParserParser.POSITIONAL_PARAMETER:
699
+ case WebdaQLParserParser.NAMED_PARAMETER:
654
700
  {
655
- _localctx = new AtomExpressionContext(_localctx);
656
- this._ctx = _localctx;
657
- _prevctx = _localctx;
658
- this.state = 105;
659
- this.atom();
701
+ this.state = 122;
702
+ this.parameter();
660
703
  }
661
704
  break;
705
+ default:
706
+ throw new NoViableAltException(this);
662
707
  }
663
- this._ctx._stop = this._input.tryLT(-1);
664
- this.state = 116;
708
+ }
709
+ }
710
+ catch (re) {
711
+ if (re instanceof RecognitionException) {
712
+ _localctx.exception = re;
713
+ this._errHandler.reportError(this, re);
714
+ this._errHandler.recover(this, re);
715
+ }
716
+ else {
717
+ throw re;
718
+ }
719
+ }
720
+ finally {
721
+ this.exitRule();
722
+ }
723
+ return _localctx;
724
+ }
725
+ // @RuleVersion(0)
726
+ fieldList() {
727
+ let _localctx = new FieldListContext(this._ctx, this.state);
728
+ this.enterRule(_localctx, 18, WebdaQLParserParser.RULE_fieldList);
729
+ let _la;
730
+ try {
731
+ this.enterOuterAlt(_localctx, 1);
732
+ {
733
+ this.state = 125;
734
+ this.selectItem();
735
+ this.state = 130;
665
736
  this._errHandler.sync(this);
666
- _alt = this.interpreter.adaptivePredict(this._input, 14, this._ctx);
667
- while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
668
- if (_alt === 1) {
669
- if (this._parseListeners != null) {
670
- this.triggerExitRuleEvent();
671
- }
672
- _prevctx = _localctx;
737
+ _la = this._input.LA(1);
738
+ while (_la === WebdaQLParserParser.COMMA) {
739
+ {
673
740
  {
674
- this.state = 114;
675
- this._errHandler.sync(this);
676
- switch (this.interpreter.adaptivePredict(this._input, 13, this._ctx)) {
677
- case 1:
678
- {
679
- _localctx = new AndLogicExpressionContext(new ExpressionContext(_parentctx, _parentState));
680
- this.pushNewRecursionContext(_localctx, _startState, WebdaQLParserParser.RULE_expression);
681
- this.state = 108;
682
- if (!this.precpred(this._ctx, 4)) {
683
- throw this.createFailedPredicateException("this.precpred(this._ctx, 4)");
684
- }
685
- this.state = 109;
686
- this.match(WebdaQLParserParser.AND);
687
- this.state = 110;
688
- this.expression(5);
689
- }
690
- break;
691
- case 2:
692
- {
693
- _localctx = new OrLogicExpressionContext(new ExpressionContext(_parentctx, _parentState));
694
- this.pushNewRecursionContext(_localctx, _startState, WebdaQLParserParser.RULE_expression);
695
- this.state = 111;
696
- if (!this.precpred(this._ctx, 3)) {
697
- throw this.createFailedPredicateException("this.precpred(this._ctx, 3)");
698
- }
699
- this.state = 112;
700
- this.match(WebdaQLParserParser.OR);
701
- this.state = 113;
702
- this.expression(4);
703
- }
704
- break;
705
- }
741
+ this.state = 126;
742
+ this.match(WebdaQLParserParser.COMMA);
743
+ this.state = 127;
744
+ this.selectItem();
706
745
  }
707
746
  }
708
- this.state = 118;
747
+ this.state = 132;
709
748
  this._errHandler.sync(this);
710
- _alt = this.interpreter.adaptivePredict(this._input, 14, this._ctx);
749
+ _la = this._input.LA(1);
711
750
  }
712
751
  }
713
752
  }
@@ -722,103 +761,100 @@ export class WebdaQLParserParser extends Parser {
722
761
  }
723
762
  }
724
763
  finally {
725
- this.unrollRecursionContexts(_parentctx);
764
+ this.exitRule();
726
765
  }
727
766
  return _localctx;
728
767
  }
729
768
  // @RuleVersion(0)
730
- values() {
731
- let _localctx = new ValuesContext(this._ctx, this.state);
732
- this.enterRule(_localctx, 12, WebdaQLParserParser.RULE_values);
769
+ selectItem() {
770
+ let _localctx = new SelectItemContext(this._ctx, this.state);
771
+ this.enterRule(_localctx, 20, WebdaQLParserParser.RULE_selectItem);
772
+ let _la;
733
773
  try {
734
- this.state = 123;
774
+ this.state = 155;
735
775
  this._errHandler.sync(this);
736
- switch (this._input.LA(1)) {
737
- case WebdaQLParserParser.TRUE:
738
- case WebdaQLParserParser.FALSE:
739
- _localctx = new BooleanAtomContext(_localctx);
776
+ switch (this.interpreter.adaptivePredict(this._input, 18, this._ctx)) {
777
+ case 1:
778
+ _localctx = new FieldItemContext(_localctx);
740
779
  this.enterOuterAlt(_localctx, 1);
741
780
  {
742
- this.state = 119;
743
- this.booleanLiteral();
781
+ this.state = 133;
782
+ this.identifier();
744
783
  }
745
784
  break;
746
- case WebdaQLParserParser.INTEGER_LITERAL:
747
- _localctx = new IntegerAtomContext(_localctx);
785
+ case 2:
786
+ _localctx = new CountAllItemContext(_localctx);
748
787
  this.enterOuterAlt(_localctx, 2);
749
788
  {
750
- this.state = 120;
751
- this.integerLiteral();
789
+ this.state = 134;
790
+ this.match(WebdaQLParserParser.COUNT);
791
+ this.state = 135;
792
+ this.match(WebdaQLParserParser.LR_BRACKET);
793
+ this.state = 136;
794
+ this.match(WebdaQLParserParser.STAR);
795
+ this.state = 137;
796
+ this.match(WebdaQLParserParser.RR_BRACKET);
797
+ this.state = 138;
798
+ this.match(WebdaQLParserParser.AS);
799
+ this.state = 139;
800
+ this.identifier();
752
801
  }
753
802
  break;
754
- case WebdaQLParserParser.NUMBER_LITERAL:
755
- _localctx = new NumberAtomContext(_localctx);
803
+ case 3:
804
+ _localctx = new CountDistinctItemContext(_localctx);
756
805
  this.enterOuterAlt(_localctx, 3);
757
806
  {
758
- this.state = 121;
759
- this.numberLiteral();
807
+ this.state = 140;
808
+ this.match(WebdaQLParserParser.COUNT);
809
+ this.state = 141;
810
+ this.match(WebdaQLParserParser.LR_BRACKET);
811
+ this.state = 142;
812
+ this.match(WebdaQLParserParser.DISTINCT);
813
+ this.state = 143;
814
+ this.identifier();
815
+ this.state = 144;
816
+ this.match(WebdaQLParserParser.RR_BRACKET);
817
+ this.state = 145;
818
+ this.match(WebdaQLParserParser.AS);
819
+ this.state = 146;
820
+ this.identifier();
760
821
  }
761
822
  break;
762
- case WebdaQLParserParser.DQUOTED_STRING_LITERAL:
763
- case WebdaQLParserParser.SQUOTED_STRING_LITERAL:
764
- _localctx = new StringAtomContext(_localctx);
823
+ case 4:
824
+ _localctx = new MetricItemContext(_localctx);
765
825
  this.enterOuterAlt(_localctx, 4);
766
826
  {
767
- this.state = 122;
768
- this.stringLiteral();
769
- }
770
- break;
771
- default:
772
- throw new NoViableAltException(this);
773
- }
774
- }
775
- catch (re) {
776
- if (re instanceof RecognitionException) {
777
- _localctx.exception = re;
778
- this._errHandler.reportError(this, re);
779
- this._errHandler.recover(this, re);
780
- }
781
- else {
782
- throw re;
783
- }
784
- }
785
- finally {
786
- this.exitRule();
787
- }
788
- return _localctx;
789
- }
790
- // @RuleVersion(0)
791
- atom() {
792
- let _localctx = new AtomContext(this._ctx, this.state);
793
- this.enterRule(_localctx, 14, WebdaQLParserParser.RULE_atom);
794
- try {
795
- this.state = 127;
796
- this._errHandler.sync(this);
797
- switch (this._input.LA(1)) {
798
- case WebdaQLParserParser.TRUE:
799
- case WebdaQLParserParser.FALSE:
800
- case WebdaQLParserParser.DQUOTED_STRING_LITERAL:
801
- case WebdaQLParserParser.SQUOTED_STRING_LITERAL:
802
- case WebdaQLParserParser.INTEGER_LITERAL:
803
- case WebdaQLParserParser.NUMBER_LITERAL:
804
- _localctx = new ValuesAtomContext(_localctx);
805
- this.enterOuterAlt(_localctx, 1);
806
- {
807
- this.state = 125;
808
- this.values();
809
- }
810
- break;
811
- case WebdaQLParserParser.IDENTIFIER:
812
- case WebdaQLParserParser.IDENTIFIER_WITH_NUMBER:
813
- _localctx = new IdentifierAtomContext(_localctx);
814
- this.enterOuterAlt(_localctx, 2);
815
- {
816
- this.state = 126;
827
+ this.state = 148;
828
+ _la = this._input.LA(1);
829
+ if (!(((_la - 38) & ~0x1f) === 0 &&
830
+ ((1 << (_la - 38)) &
831
+ ((1 << (WebdaQLParserParser.COUNT - 38)) |
832
+ (1 << (WebdaQLParserParser.SUM - 38)) |
833
+ (1 << (WebdaQLParserParser.AVG - 38)) |
834
+ (1 << (WebdaQLParserParser.MIN - 38)) |
835
+ (1 << (WebdaQLParserParser.MAX - 38)))) !==
836
+ 0)) {
837
+ this._errHandler.recoverInline(this);
838
+ }
839
+ else {
840
+ if (this._input.LA(1) === Token.EOF) {
841
+ this.matchedEOF = true;
842
+ }
843
+ this._errHandler.reportMatch(this);
844
+ this.consume();
845
+ }
846
+ this.state = 149;
847
+ this.match(WebdaQLParserParser.LR_BRACKET);
848
+ this.state = 150;
849
+ this.identifier();
850
+ this.state = 151;
851
+ this.match(WebdaQLParserParser.RR_BRACKET);
852
+ this.state = 152;
853
+ this.match(WebdaQLParserParser.AS);
854
+ this.state = 153;
817
855
  this.identifier();
818
856
  }
819
857
  break;
820
- default:
821
- throw new NoViableAltException(this);
822
858
  }
823
859
  }
824
860
  catch (re) {
@@ -837,24 +873,32 @@ export class WebdaQLParserParser extends Parser {
837
873
  return _localctx;
838
874
  }
839
875
  // @RuleVersion(0)
840
- identifier() {
841
- let _localctx = new IdentifierContext(this._ctx, this.state);
842
- this.enterRule(_localctx, 16, WebdaQLParserParser.RULE_identifier);
876
+ groupByExpression() {
877
+ let _localctx = new GroupByExpressionContext(this._ctx, this.state);
878
+ this.enterRule(_localctx, 22, WebdaQLParserParser.RULE_groupByExpression);
843
879
  let _la;
844
880
  try {
845
881
  this.enterOuterAlt(_localctx, 1);
846
882
  {
847
- this.state = 129;
883
+ this.state = 157;
884
+ this.match(WebdaQLParserParser.GROUP_BY);
885
+ this.state = 158;
886
+ this.identifier();
887
+ this.state = 163;
888
+ this._errHandler.sync(this);
848
889
  _la = this._input.LA(1);
849
- if (!(_la === WebdaQLParserParser.IDENTIFIER || _la === WebdaQLParserParser.IDENTIFIER_WITH_NUMBER)) {
850
- this._errHandler.recoverInline(this);
851
- }
852
- else {
853
- if (this._input.LA(1) === Token.EOF) {
854
- this.matchedEOF = true;
890
+ while (_la === WebdaQLParserParser.COMMA) {
891
+ {
892
+ {
893
+ this.state = 159;
894
+ this.match(WebdaQLParserParser.COMMA);
895
+ this.state = 160;
896
+ this.identifier();
897
+ }
855
898
  }
856
- this._errHandler.reportMatch(this);
857
- this.consume();
899
+ this.state = 165;
900
+ this._errHandler.sync(this);
901
+ _la = this._input.LA(1);
858
902
  }
859
903
  }
860
904
  }
@@ -874,24 +918,32 @@ export class WebdaQLParserParser extends Parser {
874
918
  return _localctx;
875
919
  }
876
920
  // @RuleVersion(0)
877
- booleanLiteral() {
878
- let _localctx = new BooleanLiteralContext(this._ctx, this.state);
879
- this.enterRule(_localctx, 18, WebdaQLParserParser.RULE_booleanLiteral);
880
- let _la;
921
+ limitExpression() {
922
+ let _localctx = new LimitExpressionContext(this._ctx, this.state);
923
+ this.enterRule(_localctx, 24, WebdaQLParserParser.RULE_limitExpression);
881
924
  try {
882
925
  this.enterOuterAlt(_localctx, 1);
883
926
  {
884
- this.state = 131;
885
- _la = this._input.LA(1);
886
- if (!(_la === WebdaQLParserParser.TRUE || _la === WebdaQLParserParser.FALSE)) {
887
- this._errHandler.recoverInline(this);
888
- }
889
- else {
890
- if (this._input.LA(1) === Token.EOF) {
891
- this.matchedEOF = true;
892
- }
893
- this._errHandler.reportMatch(this);
894
- this.consume();
927
+ this.state = 166;
928
+ this.match(WebdaQLParserParser.LIMIT);
929
+ this.state = 169;
930
+ this._errHandler.sync(this);
931
+ switch (this._input.LA(1)) {
932
+ case WebdaQLParserParser.INTEGER_LITERAL:
933
+ {
934
+ this.state = 167;
935
+ this.integerLiteral();
936
+ }
937
+ break;
938
+ case WebdaQLParserParser.POSITIONAL_PARAMETER:
939
+ case WebdaQLParserParser.NAMED_PARAMETER:
940
+ {
941
+ this.state = 168;
942
+ this.parameter();
943
+ }
944
+ break;
945
+ default:
946
+ throw new NoViableAltException(this);
895
947
  }
896
948
  }
897
949
  }
@@ -911,24 +963,33 @@ export class WebdaQLParserParser extends Parser {
911
963
  return _localctx;
912
964
  }
913
965
  // @RuleVersion(0)
914
- stringLiteral() {
915
- let _localctx = new StringLiteralContext(this._ctx, this.state);
916
- this.enterRule(_localctx, 20, WebdaQLParserParser.RULE_stringLiteral);
917
- let _la;
966
+ offsetExpression() {
967
+ let _localctx = new OffsetExpressionContext(this._ctx, this.state);
968
+ this.enterRule(_localctx, 26, WebdaQLParserParser.RULE_offsetExpression);
918
969
  try {
919
970
  this.enterOuterAlt(_localctx, 1);
920
971
  {
921
- this.state = 133;
922
- _la = this._input.LA(1);
923
- if (!(_la === WebdaQLParserParser.DQUOTED_STRING_LITERAL || _la === WebdaQLParserParser.SQUOTED_STRING_LITERAL)) {
924
- this._errHandler.recoverInline(this);
925
- }
926
- else {
927
- if (this._input.LA(1) === Token.EOF) {
928
- this.matchedEOF = true;
929
- }
930
- this._errHandler.reportMatch(this);
931
- this.consume();
972
+ this.state = 171;
973
+ this.match(WebdaQLParserParser.OFFSET);
974
+ this.state = 174;
975
+ this._errHandler.sync(this);
976
+ switch (this._input.LA(1)) {
977
+ case WebdaQLParserParser.DQUOTED_STRING_LITERAL:
978
+ case WebdaQLParserParser.SQUOTED_STRING_LITERAL:
979
+ {
980
+ this.state = 172;
981
+ this.stringLiteral();
982
+ }
983
+ break;
984
+ case WebdaQLParserParser.POSITIONAL_PARAMETER:
985
+ case WebdaQLParserParser.NAMED_PARAMETER:
986
+ {
987
+ this.state = 173;
988
+ this.parameter();
989
+ }
990
+ break;
991
+ default:
992
+ throw new NoViableAltException(this);
932
993
  }
933
994
  }
934
995
  }
@@ -948,40 +1009,34 @@ export class WebdaQLParserParser extends Parser {
948
1009
  return _localctx;
949
1010
  }
950
1011
  // @RuleVersion(0)
951
- integerLiteral() {
952
- let _localctx = new IntegerLiteralContext(this._ctx, this.state);
953
- this.enterRule(_localctx, 22, WebdaQLParserParser.RULE_integerLiteral);
954
- try {
955
- this.enterOuterAlt(_localctx, 1);
956
- {
957
- this.state = 135;
958
- this.match(WebdaQLParserParser.INTEGER_LITERAL);
959
- }
960
- }
961
- catch (re) {
962
- if (re instanceof RecognitionException) {
963
- _localctx.exception = re;
964
- this._errHandler.reportError(this, re);
965
- this._errHandler.recover(this, re);
966
- }
967
- else {
968
- throw re;
969
- }
970
- }
971
- finally {
972
- this.exitRule();
973
- }
974
- return _localctx;
975
- }
976
- // @RuleVersion(0)
977
- numberLiteral() {
978
- let _localctx = new NumberLiteralContext(this._ctx, this.state);
979
- this.enterRule(_localctx, 24, WebdaQLParserParser.RULE_numberLiteral);
1012
+ orderFieldExpression() {
1013
+ let _localctx = new OrderFieldExpressionContext(this._ctx, this.state);
1014
+ this.enterRule(_localctx, 28, WebdaQLParserParser.RULE_orderFieldExpression);
1015
+ let _la;
980
1016
  try {
981
1017
  this.enterOuterAlt(_localctx, 1);
982
1018
  {
983
- this.state = 137;
984
- this.match(WebdaQLParserParser.NUMBER_LITERAL);
1019
+ this.state = 176;
1020
+ this.identifier();
1021
+ this.state = 178;
1022
+ this._errHandler.sync(this);
1023
+ _la = this._input.LA(1);
1024
+ if (_la === WebdaQLParserParser.ASC || _la === WebdaQLParserParser.DESC) {
1025
+ {
1026
+ this.state = 177;
1027
+ _la = this._input.LA(1);
1028
+ if (!(_la === WebdaQLParserParser.ASC || _la === WebdaQLParserParser.DESC)) {
1029
+ this._errHandler.recoverInline(this);
1030
+ }
1031
+ else {
1032
+ if (this._input.LA(1) === Token.EOF) {
1033
+ this.matchedEOF = true;
1034
+ }
1035
+ this._errHandler.reportMatch(this);
1036
+ this.consume();
1037
+ }
1038
+ }
1039
+ }
985
1040
  }
986
1041
  }
987
1042
  catch (re) {
@@ -1000,24 +1055,32 @@ export class WebdaQLParserParser extends Parser {
1000
1055
  return _localctx;
1001
1056
  }
1002
1057
  // @RuleVersion(0)
1003
- parameter() {
1004
- let _localctx = new ParameterContext(this._ctx, this.state);
1005
- this.enterRule(_localctx, 26, WebdaQLParserParser.RULE_parameter);
1058
+ orderExpression() {
1059
+ let _localctx = new OrderExpressionContext(this._ctx, this.state);
1060
+ this.enterRule(_localctx, 30, WebdaQLParserParser.RULE_orderExpression);
1006
1061
  let _la;
1007
1062
  try {
1008
1063
  this.enterOuterAlt(_localctx, 1);
1009
1064
  {
1010
- this.state = 139;
1065
+ this.state = 180;
1066
+ this.match(WebdaQLParserParser.ORDER_BY);
1067
+ this.state = 181;
1068
+ this.orderFieldExpression();
1069
+ this.state = 186;
1070
+ this._errHandler.sync(this);
1011
1071
  _la = this._input.LA(1);
1012
- if (!(_la === WebdaQLParserParser.POSITIONAL_PARAMETER || _la === WebdaQLParserParser.NAMED_PARAMETER)) {
1013
- this._errHandler.recoverInline(this);
1014
- }
1015
- else {
1016
- if (this._input.LA(1) === Token.EOF) {
1017
- this.matchedEOF = true;
1072
+ while (_la === WebdaQLParserParser.COMMA) {
1073
+ {
1074
+ {
1075
+ this.state = 182;
1076
+ this.match(WebdaQLParserParser.COMMA);
1077
+ this.state = 183;
1078
+ this.orderFieldExpression();
1079
+ }
1018
1080
  }
1019
- this._errHandler.reportMatch(this);
1020
- this.consume();
1081
+ this.state = 188;
1082
+ this._errHandler.sync(this);
1083
+ _la = this._input.LA(1);
1021
1084
  }
1022
1085
  }
1023
1086
  }
@@ -1037,65 +1100,189 @@ export class WebdaQLParserParser extends Parser {
1037
1100
  return _localctx;
1038
1101
  }
1039
1102
  // @RuleVersion(0)
1040
- setExpression() {
1041
- let _localctx = new SetExpressionContext(this._ctx, this.state);
1042
- this.enterRule(_localctx, 28, WebdaQLParserParser.RULE_setExpression);
1103
+ expression(_p) {
1104
+ if (_p === undefined) {
1105
+ _p = 0;
1106
+ }
1107
+ let _parentctx = this._ctx;
1108
+ let _parentState = this.state;
1109
+ let _localctx = new ExpressionContext(this._ctx, _parentState);
1110
+ let _prevctx = _localctx;
1111
+ let _startState = 32;
1112
+ this.enterRecursionRule(_localctx, 32, WebdaQLParserParser.RULE_expression, _p);
1043
1113
  let _la;
1044
1114
  try {
1115
+ let _alt;
1045
1116
  this.enterOuterAlt(_localctx, 1);
1046
1117
  {
1047
- this.state = 141;
1048
- this.match(WebdaQLParserParser.LR_SQ_BRACKET);
1049
- this.state = 144;
1050
- this._errHandler.sync(this);
1051
- switch (this._input.LA(1)) {
1052
- case WebdaQLParserParser.TRUE:
1053
- case WebdaQLParserParser.FALSE:
1054
- case WebdaQLParserParser.DQUOTED_STRING_LITERAL:
1055
- case WebdaQLParserParser.SQUOTED_STRING_LITERAL:
1056
- case WebdaQLParserParser.INTEGER_LITERAL:
1057
- case WebdaQLParserParser.NUMBER_LITERAL:
1058
- {
1059
- this.state = 142;
1060
- this.values();
1061
- }
1062
- break;
1063
- case WebdaQLParserParser.POSITIONAL_PARAMETER:
1064
- case WebdaQLParserParser.NAMED_PARAMETER:
1065
- {
1066
- this.state = 143;
1067
- this.parameter();
1068
- }
1069
- break;
1070
- default:
1071
- throw new NoViableAltException(this);
1072
- }
1073
- this.state = 153;
1118
+ this.state = 228;
1074
1119
  this._errHandler.sync(this);
1075
- _la = this._input.LA(1);
1076
- while (_la === WebdaQLParserParser.COMMA) {
1077
- {
1120
+ switch (this.interpreter.adaptivePredict(this._input, 28, this._ctx)) {
1121
+ case 1:
1078
1122
  {
1079
- this.state = 146;
1080
- this.match(WebdaQLParserParser.COMMA);
1081
- this.state = 149;
1123
+ _localctx = new LikeExpressionContext(_localctx);
1124
+ this._ctx = _localctx;
1125
+ _prevctx = _localctx;
1126
+ this.state = 190;
1127
+ this.identifier();
1128
+ this.state = 191;
1129
+ this.match(WebdaQLParserParser.LIKE);
1130
+ this.state = 194;
1082
1131
  this._errHandler.sync(this);
1083
1132
  switch (this._input.LA(1)) {
1084
- case WebdaQLParserParser.TRUE:
1085
- case WebdaQLParserParser.FALSE:
1086
1133
  case WebdaQLParserParser.DQUOTED_STRING_LITERAL:
1087
1134
  case WebdaQLParserParser.SQUOTED_STRING_LITERAL:
1088
- case WebdaQLParserParser.INTEGER_LITERAL:
1135
+ {
1136
+ this.state = 192;
1137
+ this.stringLiteral();
1138
+ }
1139
+ break;
1140
+ case WebdaQLParserParser.POSITIONAL_PARAMETER:
1141
+ case WebdaQLParserParser.NAMED_PARAMETER:
1142
+ {
1143
+ this.state = 193;
1144
+ this.parameter();
1145
+ }
1146
+ break;
1147
+ default:
1148
+ throw new NoViableAltException(this);
1149
+ }
1150
+ }
1151
+ break;
1152
+ case 2:
1153
+ {
1154
+ _localctx = new InExpressionContext(_localctx);
1155
+ this._ctx = _localctx;
1156
+ _prevctx = _localctx;
1157
+ this.state = 196;
1158
+ this.identifier();
1159
+ this.state = 197;
1160
+ this.match(WebdaQLParserParser.IN);
1161
+ this.state = 200;
1162
+ this._errHandler.sync(this);
1163
+ switch (this._input.LA(1)) {
1164
+ case WebdaQLParserParser.LR_SQ_BRACKET:
1165
+ {
1166
+ this.state = 198;
1167
+ this.setExpression();
1168
+ }
1169
+ break;
1170
+ case WebdaQLParserParser.POSITIONAL_PARAMETER:
1171
+ case WebdaQLParserParser.NAMED_PARAMETER:
1172
+ {
1173
+ this.state = 199;
1174
+ this.parameter();
1175
+ }
1176
+ break;
1177
+ default:
1178
+ throw new NoViableAltException(this);
1179
+ }
1180
+ }
1181
+ break;
1182
+ case 3:
1183
+ {
1184
+ _localctx = new ContainsExpressionContext(_localctx);
1185
+ this._ctx = _localctx;
1186
+ _prevctx = _localctx;
1187
+ this.state = 202;
1188
+ this.identifier();
1189
+ this.state = 203;
1190
+ this.match(WebdaQLParserParser.CONTAINS);
1191
+ this.state = 206;
1192
+ this._errHandler.sync(this);
1193
+ switch (this._input.LA(1)) {
1194
+ case WebdaQLParserParser.DQUOTED_STRING_LITERAL:
1195
+ case WebdaQLParserParser.SQUOTED_STRING_LITERAL:
1196
+ {
1197
+ this.state = 204;
1198
+ this.stringLiteral();
1199
+ }
1200
+ break;
1201
+ case WebdaQLParserParser.POSITIONAL_PARAMETER:
1202
+ case WebdaQLParserParser.NAMED_PARAMETER:
1203
+ {
1204
+ this.state = 205;
1205
+ this.parameter();
1206
+ }
1207
+ break;
1208
+ default:
1209
+ throw new NoViableAltException(this);
1210
+ }
1211
+ }
1212
+ break;
1213
+ case 4:
1214
+ {
1215
+ _localctx = new IsNullExpressionContext(_localctx);
1216
+ this._ctx = _localctx;
1217
+ _prevctx = _localctx;
1218
+ this.state = 208;
1219
+ this.identifier();
1220
+ this.state = 209;
1221
+ this.match(WebdaQLParserParser.IS);
1222
+ this.state = 210;
1223
+ this.match(WebdaQLParserParser.NULL);
1224
+ }
1225
+ break;
1226
+ case 5:
1227
+ {
1228
+ _localctx = new IsNotNullExpressionContext(_localctx);
1229
+ this._ctx = _localctx;
1230
+ _prevctx = _localctx;
1231
+ this.state = 212;
1232
+ this.identifier();
1233
+ this.state = 213;
1234
+ this.match(WebdaQLParserParser.IS);
1235
+ this.state = 214;
1236
+ this.match(WebdaQLParserParser.NOT);
1237
+ this.state = 215;
1238
+ this.match(WebdaQLParserParser.NULL);
1239
+ }
1240
+ break;
1241
+ case 6:
1242
+ {
1243
+ _localctx = new BinaryComparisonExpressionContext(_localctx);
1244
+ this._ctx = _localctx;
1245
+ _prevctx = _localctx;
1246
+ this.state = 217;
1247
+ this.identifier();
1248
+ this.state = 218;
1249
+ _la = this._input.LA(1);
1250
+ if (!((_la & ~0x1f) === 0 &&
1251
+ ((1 << _la) &
1252
+ ((1 << WebdaQLParserParser.EQUAL) |
1253
+ (1 << WebdaQLParserParser.NOT_EQUAL) |
1254
+ (1 << WebdaQLParserParser.GREATER) |
1255
+ (1 << WebdaQLParserParser.GREATER_OR_EQUAL) |
1256
+ (1 << WebdaQLParserParser.LESS) |
1257
+ (1 << WebdaQLParserParser.LESS_OR_EQUAL))) !==
1258
+ 0)) {
1259
+ this._errHandler.recoverInline(this);
1260
+ }
1261
+ else {
1262
+ if (this._input.LA(1) === Token.EOF) {
1263
+ this.matchedEOF = true;
1264
+ }
1265
+ this._errHandler.reportMatch(this);
1266
+ this.consume();
1267
+ }
1268
+ this.state = 221;
1269
+ this._errHandler.sync(this);
1270
+ switch (this._input.LA(1)) {
1271
+ case WebdaQLParserParser.TRUE:
1272
+ case WebdaQLParserParser.FALSE:
1273
+ case WebdaQLParserParser.DQUOTED_STRING_LITERAL:
1274
+ case WebdaQLParserParser.SQUOTED_STRING_LITERAL:
1275
+ case WebdaQLParserParser.INTEGER_LITERAL:
1089
1276
  case WebdaQLParserParser.NUMBER_LITERAL:
1090
1277
  {
1091
- this.state = 147;
1278
+ this.state = 219;
1092
1279
  this.values();
1093
1280
  }
1094
1281
  break;
1095
1282
  case WebdaQLParserParser.POSITIONAL_PARAMETER:
1096
1283
  case WebdaQLParserParser.NAMED_PARAMETER:
1097
1284
  {
1098
- this.state = 148;
1285
+ this.state = 220;
1099
1286
  this.parameter();
1100
1287
  }
1101
1288
  break;
@@ -1103,13 +1290,79 @@ export class WebdaQLParserParser extends Parser {
1103
1290
  throw new NoViableAltException(this);
1104
1291
  }
1105
1292
  }
1293
+ break;
1294
+ case 7:
1295
+ {
1296
+ _localctx = new SubExpressionContext(_localctx);
1297
+ this._ctx = _localctx;
1298
+ _prevctx = _localctx;
1299
+ this.state = 223;
1300
+ this.match(WebdaQLParserParser.LR_BRACKET);
1301
+ this.state = 224;
1302
+ this.expression(0);
1303
+ this.state = 225;
1304
+ this.match(WebdaQLParserParser.RR_BRACKET);
1305
+ }
1306
+ break;
1307
+ case 8:
1308
+ {
1309
+ _localctx = new AtomExpressionContext(_localctx);
1310
+ this._ctx = _localctx;
1311
+ _prevctx = _localctx;
1312
+ this.state = 227;
1313
+ this.atom();
1314
+ }
1315
+ break;
1316
+ }
1317
+ this._ctx._stop = this._input.tryLT(-1);
1318
+ this.state = 238;
1319
+ this._errHandler.sync(this);
1320
+ _alt = this.interpreter.adaptivePredict(this._input, 30, this._ctx);
1321
+ while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
1322
+ if (_alt === 1) {
1323
+ if (this._parseListeners != null) {
1324
+ this.triggerExitRuleEvent();
1325
+ }
1326
+ _prevctx = _localctx;
1327
+ {
1328
+ this.state = 236;
1329
+ this._errHandler.sync(this);
1330
+ switch (this.interpreter.adaptivePredict(this._input, 29, this._ctx)) {
1331
+ case 1:
1332
+ {
1333
+ _localctx = new AndLogicExpressionContext(new ExpressionContext(_parentctx, _parentState));
1334
+ this.pushNewRecursionContext(_localctx, _startState, WebdaQLParserParser.RULE_expression);
1335
+ this.state = 230;
1336
+ if (!this.precpred(this._ctx, 4)) {
1337
+ throw this.createFailedPredicateException("this.precpred(this._ctx, 4)");
1338
+ }
1339
+ this.state = 231;
1340
+ this.match(WebdaQLParserParser.AND);
1341
+ this.state = 232;
1342
+ this.expression(5);
1343
+ }
1344
+ break;
1345
+ case 2:
1346
+ {
1347
+ _localctx = new OrLogicExpressionContext(new ExpressionContext(_parentctx, _parentState));
1348
+ this.pushNewRecursionContext(_localctx, _startState, WebdaQLParserParser.RULE_expression);
1349
+ this.state = 233;
1350
+ if (!this.precpred(this._ctx, 3)) {
1351
+ throw this.createFailedPredicateException("this.precpred(this._ctx, 3)");
1352
+ }
1353
+ this.state = 234;
1354
+ this.match(WebdaQLParserParser.OR);
1355
+ this.state = 235;
1356
+ this.expression(4);
1357
+ }
1358
+ break;
1359
+ }
1360
+ }
1106
1361
  }
1107
- this.state = 155;
1362
+ this.state = 240;
1108
1363
  this._errHandler.sync(this);
1109
- _la = this._input.LA(1);
1364
+ _alt = this.interpreter.adaptivePredict(this._input, 30, this._ctx);
1110
1365
  }
1111
- this.state = 156;
1112
- this.match(WebdaQLParserParser.RR_SQ_BRACKET);
1113
1366
  }
1114
1367
  }
1115
1368
  catch (re) {
@@ -1123,141 +1376,1227 @@ export class WebdaQLParserParser extends Parser {
1123
1376
  }
1124
1377
  }
1125
1378
  finally {
1126
- this.exitRule();
1379
+ this.unrollRecursionContexts(_parentctx);
1127
1380
  }
1128
1381
  return _localctx;
1129
1382
  }
1130
- sempred(_localctx, ruleIndex, predIndex) {
1131
- switch (ruleIndex) {
1132
- case 5:
1133
- return this.expression_sempred(_localctx, predIndex);
1383
+ // @RuleVersion(0)
1384
+ values() {
1385
+ let _localctx = new ValuesContext(this._ctx, this.state);
1386
+ this.enterRule(_localctx, 34, WebdaQLParserParser.RULE_values);
1387
+ try {
1388
+ this.state = 245;
1389
+ this._errHandler.sync(this);
1390
+ switch (this._input.LA(1)) {
1391
+ case WebdaQLParserParser.TRUE:
1392
+ case WebdaQLParserParser.FALSE:
1393
+ _localctx = new BooleanAtomContext(_localctx);
1394
+ this.enterOuterAlt(_localctx, 1);
1395
+ {
1396
+ this.state = 241;
1397
+ this.booleanLiteral();
1398
+ }
1399
+ break;
1400
+ case WebdaQLParserParser.INTEGER_LITERAL:
1401
+ _localctx = new IntegerAtomContext(_localctx);
1402
+ this.enterOuterAlt(_localctx, 2);
1403
+ {
1404
+ this.state = 242;
1405
+ this.integerLiteral();
1406
+ }
1407
+ break;
1408
+ case WebdaQLParserParser.NUMBER_LITERAL:
1409
+ _localctx = new NumberAtomContext(_localctx);
1410
+ this.enterOuterAlt(_localctx, 3);
1411
+ {
1412
+ this.state = 243;
1413
+ this.numberLiteral();
1414
+ }
1415
+ break;
1416
+ case WebdaQLParserParser.DQUOTED_STRING_LITERAL:
1417
+ case WebdaQLParserParser.SQUOTED_STRING_LITERAL:
1418
+ _localctx = new StringAtomContext(_localctx);
1419
+ this.enterOuterAlt(_localctx, 4);
1420
+ {
1421
+ this.state = 244;
1422
+ this.stringLiteral();
1423
+ }
1424
+ break;
1425
+ default:
1426
+ throw new NoViableAltException(this);
1427
+ }
1134
1428
  }
1135
- return true;
1136
- }
1137
- expression_sempred(_localctx, predIndex) {
1138
- switch (predIndex) {
1139
- case 0:
1140
- return this.precpred(this._ctx, 4);
1141
- case 1:
1142
- return this.precpred(this._ctx, 3);
1429
+ catch (re) {
1430
+ if (re instanceof RecognitionException) {
1431
+ _localctx.exception = re;
1432
+ this._errHandler.reportError(this, re);
1433
+ this._errHandler.recover(this, re);
1434
+ }
1435
+ else {
1436
+ throw re;
1437
+ }
1143
1438
  }
1144
- return true;
1145
- }
1146
- static _serializedATN = "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03(\xA1\x04\x02" +
1147
- "\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04\x07" +
1148
- "\t\x07\x04\b\t\b\x04\t\t\t\x04\n\t\n\x04\v\t\v\x04\f\t\f\x04\r\t\r\x04" +
1149
- '\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t\x10\x03\x02\x05\x02"\n\x02\x03\x02' +
1150
- "\x05\x02%\n\x02\x03\x02\x05\x02(\n\x02\x03\x02\x05\x02+\n\x02\x03\x02" +
1151
- "\x03\x02\x03\x03\x03\x03\x03\x03\x05\x032\n\x03\x03\x04\x03\x04\x03\x04" +
1152
- "\x05\x047\n\x04\x03\x05\x03\x05\x05\x05;\n\x05\x03\x06\x03\x06\x03\x06" +
1153
- "\x03\x06\x07\x06A\n\x06\f\x06\x0E\x06D\v\x06\x03\x07\x03\x07\x03\x07\x03" +
1154
- "\x07\x03\x07\x05\x07K\n\x07\x03\x07\x03\x07\x03\x07\x03\x07\x05\x07Q\n" +
1155
- "\x07\x03\x07\x03\x07\x03\x07\x03\x07\x05\x07W\n\x07\x03\x07\x03\x07\x03" +
1156
- "\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03" +
1157
- "\x07\x03\x07\x05\x07f\n\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x05" +
1158
- "\x07m\n\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x07\x07u\n" +
1159
- "\x07\f\x07\x0E\x07x\v\x07\x03\b\x03\b\x03\b\x03\b\x05\b~\n\b\x03\t\x03" +
1160
- "\t\x05\t\x82\n\t\x03\n\x03\n\x03\v\x03\v\x03\f\x03\f\x03\r\x03\r\x03\x0E" +
1161
- "\x03\x0E\x03\x0F\x03\x0F\x03\x10\x03\x10\x03\x10\x05\x10\x93\n\x10\x03" +
1162
- "\x10\x03\x10\x03\x10\x05\x10\x98\n\x10\x07\x10\x9A\n\x10\f\x10\x0E\x10" +
1163
- "\x9D\v\x10\x03\x10\x03\x10\x03\x10\x02\x02\x03\f\x11\x02\x02\x04\x02\x06" +
1164
- "\x02\b\x02\n\x02\f\x02\x0E\x02\x10\x02\x12\x02\x14\x02\x16\x02\x18\x02" +
1165
- "\x1A\x02\x1C\x02\x1E\x02\x02\b\x03\x02\x1E\x1F\x03\x02\r\x12\x03\x02&" +
1166
- "\'\x03\x02\x19\x1A\x03\x02 !\x03\x02$%\x02\xAD\x02!\x03\x02\x02\x02\x04" +
1167
- ".\x03\x02\x02\x02\x063\x03\x02\x02\x02\b8\x03\x02\x02\x02\n<\x03\x02\x02" +
1168
- "\x02\fl\x03\x02\x02\x02\x0E}\x03\x02\x02\x02\x10\x81\x03\x02\x02\x02\x12" +
1169
- "\x83\x03\x02\x02\x02\x14\x85\x03\x02\x02\x02\x16\x87\x03\x02\x02\x02\x18" +
1170
- "\x89\x03\x02\x02\x02\x1A\x8B\x03\x02\x02\x02\x1C\x8D\x03\x02\x02\x02\x1E" +
1171
- '\x8F\x03\x02\x02\x02 "\x05\f\x07\x02! \x03\x02\x02\x02!"\x03\x02\x02' +
1172
- '\x02"$\x03\x02\x02\x02#%\x05\n\x06\x02$#\x03\x02\x02\x02$%\x03\x02\x02' +
1173
- "\x02%\'\x03\x02\x02\x02&(\x05\x04\x03\x02\'&\x03\x02\x02\x02\'(\x03\x02" +
1174
- "\x02\x02(*\x03\x02\x02\x02)+\x05\x06\x04\x02*)\x03\x02\x02\x02*+\x03\x02" +
1175
- "\x02\x02+,\x03\x02\x02\x02,-\x07\x02\x02\x03-\x03\x03\x02\x02\x02.1\x07" +
1176
- "\x1B\x02\x02/2\x05\x18\r\x0202\x05\x1C\x0F\x021/\x03\x02\x02\x0210\x03" +
1177
- "\x02\x02\x022\x05\x03\x02\x02\x0236\x07\x1C\x02\x0247\x05\x16\f\x0257" +
1178
- "\x05\x1C\x0F\x0264\x03\x02\x02\x0265\x03\x02\x02\x027\x07\x03\x02\x02" +
1179
- "\x028:\x05\x12\n\x029;\t\x02\x02\x02:9\x03\x02\x02\x02:;\x03\x02\x02\x02" +
1180
- ";\t\x03\x02\x02\x02<=\x07\x1D\x02\x02=B\x05\b\x05\x02>?\x07\x06\x02\x02" +
1181
- "?A\x05\b\x05\x02@>\x03\x02\x02\x02AD\x03\x02\x02\x02B@\x03\x02\x02\x02" +
1182
- "BC\x03\x02\x02\x02C\v\x03\x02\x02\x02DB\x03\x02\x02\x02EF\b\x07\x01\x02" +
1183
- "FG\x05\x12\n\x02GJ\x07\x13\x02\x02HK\x05\x16\f\x02IK\x05\x1C\x0F\x02J" +
1184
- "H\x03\x02\x02\x02JI\x03\x02\x02\x02Km\x03\x02\x02\x02LM\x05\x12\n\x02" +
1185
- "MP\x07\x14\x02\x02NQ\x05\x1E\x10\x02OQ\x05\x1C\x0F\x02PN\x03\x02\x02\x02" +
1186
- "PO\x03\x02\x02\x02Qm\x03\x02\x02\x02RS\x05\x12\n\x02SV\x07\x15\x02\x02" +
1187
- "TW\x05\x16\f\x02UW\x05\x1C\x0F\x02VT\x03\x02\x02\x02VU\x03\x02\x02\x02" +
1188
- "Wm\x03\x02\x02\x02XY\x05\x12\n\x02YZ\x07\x16\x02\x02Z[\x07\x18\x02\x02" +
1189
- "[m\x03\x02\x02\x02\\]\x05\x12\n\x02]^\x07\x16\x02\x02^_\x07\x17\x02\x02" +
1190
- "_`\x07\x18\x02\x02`m\x03\x02\x02\x02ab\x05\x12\n\x02be\t\x03\x02\x02c" +
1191
- "f\x05\x0E\b\x02df\x05\x1C\x0F\x02ec\x03\x02\x02\x02ed\x03\x02\x02\x02" +
1192
- "fm\x03\x02\x02\x02gh\x07\x04\x02\x02hi\x05\f\x07\x02ij\x07\x05\x02\x02" +
1193
- "jm\x03\x02\x02\x02km\x05\x10\t\x02lE\x03\x02\x02\x02lL\x03\x02\x02\x02" +
1194
- "lR\x03\x02\x02\x02lX\x03\x02\x02\x02l\\\x03\x02\x02\x02la\x03\x02\x02" +
1195
- "\x02lg\x03\x02\x02\x02lk\x03\x02\x02\x02mv\x03\x02\x02\x02no\f\x06\x02" +
1196
- "\x02op\x07\v\x02\x02pu\x05\f\x07\x07qr\f\x05\x02\x02rs\x07\f\x02\x02s" +
1197
- "u\x05\f\x07\x06tn\x03\x02\x02\x02tq\x03\x02\x02\x02ux\x03\x02\x02\x02" +
1198
- "vt\x03\x02\x02\x02vw\x03\x02\x02\x02w\r\x03\x02\x02\x02xv\x03\x02\x02" +
1199
- "\x02y~\x05\x14\v\x02z~\x05\x18\r\x02{~\x05\x1A\x0E\x02|~\x05\x16\f\x02" +
1200
- "}y\x03\x02\x02\x02}z\x03\x02\x02\x02}{\x03\x02\x02\x02}|\x03\x02\x02\x02" +
1201
- "~\x0F\x03\x02\x02\x02\x7F\x82\x05\x0E\b\x02\x80\x82\x05\x12\n\x02\x81" +
1202
- "\x7F\x03\x02\x02\x02\x81\x80\x03\x02\x02\x02\x82\x11\x03\x02\x02\x02\x83" +
1203
- "\x84\t\x04\x02\x02\x84\x13\x03\x02\x02\x02\x85\x86\t\x05\x02\x02\x86\x15" +
1204
- "\x03\x02\x02\x02\x87\x88\t\x06\x02\x02\x88\x17\x03\x02\x02\x02\x89\x8A" +
1205
- '\x07"\x02\x02\x8A\x19\x03\x02\x02\x02\x8B\x8C\x07#\x02\x02\x8C\x1B\x03' +
1206
- "\x02\x02\x02\x8D\x8E\t\x07\x02\x02\x8E\x1D\x03\x02\x02\x02\x8F\x92\x07" +
1207
- "\t\x02\x02\x90\x93\x05\x0E\b\x02\x91\x93\x05\x1C\x0F\x02\x92\x90\x03\x02" +
1208
- "\x02\x02\x92\x91\x03\x02\x02\x02\x93\x9B\x03\x02\x02\x02\x94\x97\x07\x06" +
1209
- "\x02\x02\x95\x98\x05\x0E\b\x02\x96\x98\x05\x1C\x0F\x02\x97\x95\x03\x02" +
1210
- "\x02\x02\x97\x96\x03\x02\x02\x02\x98\x9A\x03\x02\x02\x02\x99\x94\x03\x02" +
1211
- "\x02\x02\x9A\x9D\x03\x02\x02\x02\x9B\x99\x03\x02\x02\x02\x9B\x9C\x03\x02" +
1212
- "\x02\x02\x9C\x9E\x03\x02\x02\x02\x9D\x9B\x03\x02\x02\x02\x9E\x9F\x07\n" +
1213
- "\x02\x02\x9F\x1F\x03\x02\x02\x02\x16!$\'*16:BJPVeltv}\x81\x92\x97\x9B";
1214
- static __ATN;
1215
- static get _ATN() {
1216
- if (!WebdaQLParserParser.__ATN) {
1217
- WebdaQLParserParser.__ATN = new ATNDeserializer().deserialize(Utils.toCharArray(WebdaQLParserParser._serializedATN));
1439
+ finally {
1440
+ this.exitRule();
1218
1441
  }
1219
- return WebdaQLParserParser.__ATN;
1220
- }
1221
- }
1222
- export class WebdaqlContext extends ParserRuleContext {
1223
- EOF() {
1224
- return this.getToken(WebdaQLParserParser.EOF, 0);
1225
- }
1226
- expression() {
1227
- return this.tryGetRuleContext(0, ExpressionContext);
1442
+ return _localctx;
1443
+ }
1444
+ // @RuleVersion(0)
1445
+ atom() {
1446
+ let _localctx = new AtomContext(this._ctx, this.state);
1447
+ this.enterRule(_localctx, 36, WebdaQLParserParser.RULE_atom);
1448
+ try {
1449
+ this.state = 249;
1450
+ this._errHandler.sync(this);
1451
+ switch (this._input.LA(1)) {
1452
+ case WebdaQLParserParser.TRUE:
1453
+ case WebdaQLParserParser.FALSE:
1454
+ case WebdaQLParserParser.DQUOTED_STRING_LITERAL:
1455
+ case WebdaQLParserParser.SQUOTED_STRING_LITERAL:
1456
+ case WebdaQLParserParser.INTEGER_LITERAL:
1457
+ case WebdaQLParserParser.NUMBER_LITERAL:
1458
+ _localctx = new ValuesAtomContext(_localctx);
1459
+ this.enterOuterAlt(_localctx, 1);
1460
+ {
1461
+ this.state = 247;
1462
+ this.values();
1463
+ }
1464
+ break;
1465
+ case WebdaQLParserParser.IDENTIFIER:
1466
+ case WebdaQLParserParser.IDENTIFIER_WITH_NUMBER:
1467
+ _localctx = new IdentifierAtomContext(_localctx);
1468
+ this.enterOuterAlt(_localctx, 2);
1469
+ {
1470
+ this.state = 248;
1471
+ this.identifier();
1472
+ }
1473
+ break;
1474
+ default:
1475
+ throw new NoViableAltException(this);
1476
+ }
1477
+ }
1478
+ catch (re) {
1479
+ if (re instanceof RecognitionException) {
1480
+ _localctx.exception = re;
1481
+ this._errHandler.reportError(this, re);
1482
+ this._errHandler.recover(this, re);
1483
+ }
1484
+ else {
1485
+ throw re;
1486
+ }
1487
+ }
1488
+ finally {
1489
+ this.exitRule();
1490
+ }
1491
+ return _localctx;
1492
+ }
1493
+ // @RuleVersion(0)
1494
+ identifier() {
1495
+ let _localctx = new IdentifierContext(this._ctx, this.state);
1496
+ this.enterRule(_localctx, 38, WebdaQLParserParser.RULE_identifier);
1497
+ let _la;
1498
+ try {
1499
+ this.enterOuterAlt(_localctx, 1);
1500
+ {
1501
+ this.state = 251;
1502
+ _la = this._input.LA(1);
1503
+ if (!(_la === WebdaQLParserParser.IDENTIFIER || _la === WebdaQLParserParser.IDENTIFIER_WITH_NUMBER)) {
1504
+ this._errHandler.recoverInline(this);
1505
+ }
1506
+ else {
1507
+ if (this._input.LA(1) === Token.EOF) {
1508
+ this.matchedEOF = true;
1509
+ }
1510
+ this._errHandler.reportMatch(this);
1511
+ this.consume();
1512
+ }
1513
+ }
1514
+ }
1515
+ catch (re) {
1516
+ if (re instanceof RecognitionException) {
1517
+ _localctx.exception = re;
1518
+ this._errHandler.reportError(this, re);
1519
+ this._errHandler.recover(this, re);
1520
+ }
1521
+ else {
1522
+ throw re;
1523
+ }
1524
+ }
1525
+ finally {
1526
+ this.exitRule();
1527
+ }
1528
+ return _localctx;
1529
+ }
1530
+ // @RuleVersion(0)
1531
+ booleanLiteral() {
1532
+ let _localctx = new BooleanLiteralContext(this._ctx, this.state);
1533
+ this.enterRule(_localctx, 40, WebdaQLParserParser.RULE_booleanLiteral);
1534
+ let _la;
1535
+ try {
1536
+ this.enterOuterAlt(_localctx, 1);
1537
+ {
1538
+ this.state = 253;
1539
+ _la = this._input.LA(1);
1540
+ if (!(_la === WebdaQLParserParser.TRUE || _la === WebdaQLParserParser.FALSE)) {
1541
+ this._errHandler.recoverInline(this);
1542
+ }
1543
+ else {
1544
+ if (this._input.LA(1) === Token.EOF) {
1545
+ this.matchedEOF = true;
1546
+ }
1547
+ this._errHandler.reportMatch(this);
1548
+ this.consume();
1549
+ }
1550
+ }
1551
+ }
1552
+ catch (re) {
1553
+ if (re instanceof RecognitionException) {
1554
+ _localctx.exception = re;
1555
+ this._errHandler.reportError(this, re);
1556
+ this._errHandler.recover(this, re);
1557
+ }
1558
+ else {
1559
+ throw re;
1560
+ }
1561
+ }
1562
+ finally {
1563
+ this.exitRule();
1564
+ }
1565
+ return _localctx;
1566
+ }
1567
+ // @RuleVersion(0)
1568
+ stringLiteral() {
1569
+ let _localctx = new StringLiteralContext(this._ctx, this.state);
1570
+ this.enterRule(_localctx, 42, WebdaQLParserParser.RULE_stringLiteral);
1571
+ let _la;
1572
+ try {
1573
+ this.enterOuterAlt(_localctx, 1);
1574
+ {
1575
+ this.state = 255;
1576
+ _la = this._input.LA(1);
1577
+ if (!(_la === WebdaQLParserParser.DQUOTED_STRING_LITERAL || _la === WebdaQLParserParser.SQUOTED_STRING_LITERAL)) {
1578
+ this._errHandler.recoverInline(this);
1579
+ }
1580
+ else {
1581
+ if (this._input.LA(1) === Token.EOF) {
1582
+ this.matchedEOF = true;
1583
+ }
1584
+ this._errHandler.reportMatch(this);
1585
+ this.consume();
1586
+ }
1587
+ }
1588
+ }
1589
+ catch (re) {
1590
+ if (re instanceof RecognitionException) {
1591
+ _localctx.exception = re;
1592
+ this._errHandler.reportError(this, re);
1593
+ this._errHandler.recover(this, re);
1594
+ }
1595
+ else {
1596
+ throw re;
1597
+ }
1598
+ }
1599
+ finally {
1600
+ this.exitRule();
1601
+ }
1602
+ return _localctx;
1603
+ }
1604
+ // @RuleVersion(0)
1605
+ integerLiteral() {
1606
+ let _localctx = new IntegerLiteralContext(this._ctx, this.state);
1607
+ this.enterRule(_localctx, 44, WebdaQLParserParser.RULE_integerLiteral);
1608
+ try {
1609
+ this.enterOuterAlt(_localctx, 1);
1610
+ {
1611
+ this.state = 257;
1612
+ this.match(WebdaQLParserParser.INTEGER_LITERAL);
1613
+ }
1614
+ }
1615
+ catch (re) {
1616
+ if (re instanceof RecognitionException) {
1617
+ _localctx.exception = re;
1618
+ this._errHandler.reportError(this, re);
1619
+ this._errHandler.recover(this, re);
1620
+ }
1621
+ else {
1622
+ throw re;
1623
+ }
1624
+ }
1625
+ finally {
1626
+ this.exitRule();
1627
+ }
1628
+ return _localctx;
1629
+ }
1630
+ // @RuleVersion(0)
1631
+ numberLiteral() {
1632
+ let _localctx = new NumberLiteralContext(this._ctx, this.state);
1633
+ this.enterRule(_localctx, 46, WebdaQLParserParser.RULE_numberLiteral);
1634
+ try {
1635
+ this.enterOuterAlt(_localctx, 1);
1636
+ {
1637
+ this.state = 259;
1638
+ this.match(WebdaQLParserParser.NUMBER_LITERAL);
1639
+ }
1640
+ }
1641
+ catch (re) {
1642
+ if (re instanceof RecognitionException) {
1643
+ _localctx.exception = re;
1644
+ this._errHandler.reportError(this, re);
1645
+ this._errHandler.recover(this, re);
1646
+ }
1647
+ else {
1648
+ throw re;
1649
+ }
1650
+ }
1651
+ finally {
1652
+ this.exitRule();
1653
+ }
1654
+ return _localctx;
1655
+ }
1656
+ // @RuleVersion(0)
1657
+ parameter() {
1658
+ let _localctx = new ParameterContext(this._ctx, this.state);
1659
+ this.enterRule(_localctx, 48, WebdaQLParserParser.RULE_parameter);
1660
+ let _la;
1661
+ try {
1662
+ this.enterOuterAlt(_localctx, 1);
1663
+ {
1664
+ this.state = 261;
1665
+ _la = this._input.LA(1);
1666
+ if (!(_la === WebdaQLParserParser.POSITIONAL_PARAMETER || _la === WebdaQLParserParser.NAMED_PARAMETER)) {
1667
+ this._errHandler.recoverInline(this);
1668
+ }
1669
+ else {
1670
+ if (this._input.LA(1) === Token.EOF) {
1671
+ this.matchedEOF = true;
1672
+ }
1673
+ this._errHandler.reportMatch(this);
1674
+ this.consume();
1675
+ }
1676
+ }
1677
+ }
1678
+ catch (re) {
1679
+ if (re instanceof RecognitionException) {
1680
+ _localctx.exception = re;
1681
+ this._errHandler.reportError(this, re);
1682
+ this._errHandler.recover(this, re);
1683
+ }
1684
+ else {
1685
+ throw re;
1686
+ }
1687
+ }
1688
+ finally {
1689
+ this.exitRule();
1690
+ }
1691
+ return _localctx;
1692
+ }
1693
+ // @RuleVersion(0)
1694
+ setExpression() {
1695
+ let _localctx = new SetExpressionContext(this._ctx, this.state);
1696
+ this.enterRule(_localctx, 50, WebdaQLParserParser.RULE_setExpression);
1697
+ let _la;
1698
+ try {
1699
+ this.enterOuterAlt(_localctx, 1);
1700
+ {
1701
+ this.state = 263;
1702
+ this.match(WebdaQLParserParser.LR_SQ_BRACKET);
1703
+ this.state = 266;
1704
+ this._errHandler.sync(this);
1705
+ switch (this._input.LA(1)) {
1706
+ case WebdaQLParserParser.TRUE:
1707
+ case WebdaQLParserParser.FALSE:
1708
+ case WebdaQLParserParser.DQUOTED_STRING_LITERAL:
1709
+ case WebdaQLParserParser.SQUOTED_STRING_LITERAL:
1710
+ case WebdaQLParserParser.INTEGER_LITERAL:
1711
+ case WebdaQLParserParser.NUMBER_LITERAL:
1712
+ {
1713
+ this.state = 264;
1714
+ this.values();
1715
+ }
1716
+ break;
1717
+ case WebdaQLParserParser.POSITIONAL_PARAMETER:
1718
+ case WebdaQLParserParser.NAMED_PARAMETER:
1719
+ {
1720
+ this.state = 265;
1721
+ this.parameter();
1722
+ }
1723
+ break;
1724
+ default:
1725
+ throw new NoViableAltException(this);
1726
+ }
1727
+ this.state = 275;
1728
+ this._errHandler.sync(this);
1729
+ _la = this._input.LA(1);
1730
+ while (_la === WebdaQLParserParser.COMMA) {
1731
+ {
1732
+ {
1733
+ this.state = 268;
1734
+ this.match(WebdaQLParserParser.COMMA);
1735
+ this.state = 271;
1736
+ this._errHandler.sync(this);
1737
+ switch (this._input.LA(1)) {
1738
+ case WebdaQLParserParser.TRUE:
1739
+ case WebdaQLParserParser.FALSE:
1740
+ case WebdaQLParserParser.DQUOTED_STRING_LITERAL:
1741
+ case WebdaQLParserParser.SQUOTED_STRING_LITERAL:
1742
+ case WebdaQLParserParser.INTEGER_LITERAL:
1743
+ case WebdaQLParserParser.NUMBER_LITERAL:
1744
+ {
1745
+ this.state = 269;
1746
+ this.values();
1747
+ }
1748
+ break;
1749
+ case WebdaQLParserParser.POSITIONAL_PARAMETER:
1750
+ case WebdaQLParserParser.NAMED_PARAMETER:
1751
+ {
1752
+ this.state = 270;
1753
+ this.parameter();
1754
+ }
1755
+ break;
1756
+ default:
1757
+ throw new NoViableAltException(this);
1758
+ }
1759
+ }
1760
+ }
1761
+ this.state = 277;
1762
+ this._errHandler.sync(this);
1763
+ _la = this._input.LA(1);
1764
+ }
1765
+ this.state = 278;
1766
+ this.match(WebdaQLParserParser.RR_SQ_BRACKET);
1767
+ }
1768
+ }
1769
+ catch (re) {
1770
+ if (re instanceof RecognitionException) {
1771
+ _localctx.exception = re;
1772
+ this._errHandler.reportError(this, re);
1773
+ this._errHandler.recover(this, re);
1774
+ }
1775
+ else {
1776
+ throw re;
1777
+ }
1778
+ }
1779
+ finally {
1780
+ this.exitRule();
1781
+ }
1782
+ return _localctx;
1783
+ }
1784
+ sempred(_localctx, ruleIndex, predIndex) {
1785
+ switch (ruleIndex) {
1786
+ case 16:
1787
+ return this.expression_sempred(_localctx, predIndex);
1788
+ }
1789
+ return true;
1790
+ }
1791
+ expression_sempred(_localctx, predIndex) {
1792
+ switch (predIndex) {
1793
+ case 0:
1794
+ return this.precpred(this._ctx, 4);
1795
+ case 1:
1796
+ return this.precpred(this._ctx, 3);
1797
+ }
1798
+ return true;
1799
+ }
1800
+ static _serializedATN = "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x036\u011B\x04\x02" +
1801
+ "\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04\x07" +
1802
+ "\t\x07\x04\b\t\b\x04\t\t\t\x04\n\t\n\x04\v\t\v\x04\f\t\f\x04\r\t\r\x04" +
1803
+ "\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t\x10\x04\x11\t\x11\x04\x12\t\x12\x04" +
1804
+ "\x13\t\x13\x04\x14\t\x14\x04\x15\t\x15\x04\x16\t\x16\x04\x17\t\x17\x04" +
1805
+ "\x18\t\x18\x04\x19\t\x19\x04\x1A\t\x1A\x04\x1B\t\x1B\x03\x02\x03\x02\x05" +
1806
+ "\x029\n\x02\x03\x02\x03\x02\x03\x03\x03\x03\x03\x03\x05\x03@\n\x03\x03" +
1807
+ "\x04\x03\x04\x05\x04D\n\x04\x03\x04\x05\x04G\n\x04\x03\x05\x03\x05\x03" +
1808
+ "\x05\x03\x05\x05\x05M\n\x05\x03\x05\x05\x05P\n\x05\x03\x06\x03\x06\x03" +
1809
+ "\x06\x05\x06U\n\x06\x03\x06\x05\x06X\n\x06\x03\x06\x05\x06[\n\x06\x03" +
1810
+ "\x06\x05\x06^\n\x06\x03\x06\x05\x06a\n\x06\x03\x07\x05\x07d\n\x07\x03" +
1811
+ "\x07\x05\x07g\n\x07\x03\x07\x05\x07j\n\x07\x03\x07\x05\x07m\n\x07\x03" +
1812
+ "\b\x03\b\x03\b\x03\t\x03\t\x03\t\x07\tu\n\t\f\t\x0E\tx\v\t\x03\n\x03\n" +
1813
+ "\x03\n\x03\n\x05\n~\n\n\x03\v\x03\v\x03\v\x07\v\x83\n\v\f\v\x0E\v\x86" +
1814
+ "\v\v\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f" +
1815
+ "\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x05" +
1816
+ "\f\x9E\n\f\x03\r\x03\r\x03\r\x03\r\x07\r\xA4\n\r\f\r\x0E\r\xA7\v\r\x03" +
1817
+ "\x0E\x03\x0E\x03\x0E\x05\x0E\xAC\n\x0E\x03\x0F\x03\x0F\x03\x0F\x05\x0F" +
1818
+ "\xB1\n\x0F\x03\x10\x03\x10\x05\x10\xB5\n\x10\x03\x11\x03\x11\x03\x11\x03" +
1819
+ "\x11\x07\x11\xBB\n\x11\f\x11\x0E\x11\xBE\v\x11\x03\x12\x03\x12\x03\x12" +
1820
+ "\x03\x12\x03\x12\x05\x12\xC5\n\x12\x03\x12\x03\x12\x03\x12\x03\x12\x05" +
1821
+ "\x12\xCB\n\x12\x03\x12\x03\x12\x03\x12\x03\x12\x05\x12\xD1\n\x12\x03\x12" +
1822
+ "\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12" +
1823
+ "\x03\x12\x03\x12\x03\x12\x05\x12\xE0\n\x12\x03\x12\x03\x12\x03\x12\x03" +
1824
+ "\x12\x03\x12\x05\x12\xE7\n\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12" +
1825
+ "\x03\x12\x07\x12\xEF\n\x12\f\x12\x0E\x12\xF2\v\x12\x03\x13\x03\x13\x03" +
1826
+ "\x13\x03\x13\x05\x13\xF8\n\x13\x03\x14\x03\x14\x05\x14\xFC\n\x14\x03\x15" +
1827
+ "\x03\x15\x03\x16\x03\x16\x03\x17\x03\x17\x03\x18\x03\x18\x03\x19\x03\x19" +
1828
+ "\x03\x1A\x03\x1A\x03\x1B\x03\x1B\x03\x1B\x05\x1B\u010D\n\x1B\x03\x1B\x03" +
1829
+ "\x1B\x03\x1B\x05\x1B\u0112\n\x1B\x07\x1B\u0114\n\x1B\f\x1B\x0E\x1B\u0117" +
1830
+ '\v\x1B\x03\x1B\x03\x1B\x03\x1B\x02\x02\x03"\x1C\x02\x02\x04\x02\x06\x02' +
1831
+ "\b\x02\n\x02\f\x02\x0E\x02\x10\x02\x12\x02\x14\x02\x16\x02\x18\x02\x1A" +
1832
+ '\x02\x1C\x02\x1E\x02 \x02"\x02$\x02&\x02(\x02*\x02,\x02.\x020\x022\x02' +
1833
+ "4\x02\x02\t\x03\x02(,\x03\x02#$\x03\x02\x12\x17\x03\x0245\x03\x02\x1E" +
1834
+ "\x1F\x03\x02./\x03\x0223\x02\u012F\x028\x03\x02\x02\x02\x04?\x03\x02\x02" +
1835
+ "\x02\x06A\x03\x02\x02\x02\bH\x03\x02\x02\x02\nQ\x03\x02\x02\x02\fc\x03" +
1836
+ "\x02\x02\x02\x0En\x03\x02\x02\x02\x10q\x03\x02\x02\x02\x12y\x03\x02\x02" +
1837
+ "\x02\x14\x7F\x03\x02\x02\x02\x16\x9D\x03\x02\x02\x02\x18\x9F\x03\x02\x02" +
1838
+ "\x02\x1A\xA8\x03\x02\x02\x02\x1C\xAD\x03\x02\x02\x02\x1E\xB2\x03\x02\x02" +
1839
+ '\x02 \xB6\x03\x02\x02\x02"\xE6\x03\x02\x02\x02$\xF7\x03\x02\x02\x02&' +
1840
+ "\xFB\x03\x02\x02\x02(\xFD\x03\x02\x02\x02*\xFF\x03\x02\x02\x02,\u0101" +
1841
+ "\x03\x02\x02\x02.\u0103\x03\x02\x02\x020\u0105\x03\x02\x02\x022\u0107" +
1842
+ "\x03\x02\x02\x024\u0109\x03\x02\x02\x0269\x05\x04\x03\x0279\x05\f\x07" +
1843
+ "\x0286\x03\x02\x02\x0287\x03\x02\x02\x029:\x03\x02\x02\x02:;\x07\x02\x02" +
1844
+ "\x03;\x03\x03\x02\x02\x02<@\x05\x06\x04\x02=@\x05\b\x05\x02>@\x05\n\x06" +
1845
+ "\x02?<\x03\x02\x02\x02?=\x03\x02\x02\x02?>\x03\x02\x02\x02@\x05\x03\x02" +
1846
+ "\x02\x02AC\x07\v\x02\x02BD\x05\x0E\b\x02CB\x03\x02\x02\x02CD\x03\x02\x02" +
1847
+ "\x02DF\x03\x02\x02\x02EG\x05\x1A\x0E\x02FE\x03\x02\x02\x02FG\x03\x02\x02" +
1848
+ "\x02G\x07\x03\x02\x02\x02HI\x07\f\x02\x02IJ\x07\x0E\x02\x02JL\x05\x10" +
1849
+ "\t\x02KM\x05\x0E\b\x02LK\x03\x02\x02\x02LM\x03\x02\x02\x02MO\x03\x02\x02" +
1850
+ "\x02NP\x05\x1A\x0E\x02ON\x03\x02\x02\x02OP\x03\x02\x02\x02P\t\x03\x02" +
1851
+ "\x02\x02QR\x07\r\x02\x02RT\x05\x14\v\x02SU\x05\x0E\b\x02TS\x03\x02\x02" +
1852
+ "\x02TU\x03\x02\x02\x02UW\x03\x02\x02\x02VX\x05\x18\r\x02WV\x03\x02\x02" +
1853
+ "\x02WX\x03\x02\x02\x02XZ\x03\x02\x02\x02Y[\x05 \x11\x02ZY\x03\x02\x02" +
1854
+ "\x02Z[\x03\x02\x02\x02[]\x03\x02\x02\x02\\^\x05\x1A\x0E\x02]\\\x03\x02" +
1855
+ "\x02\x02]^\x03\x02\x02\x02^`\x03\x02\x02\x02_a\x05\x1C\x0F\x02`_\x03\x02" +
1856
+ '\x02\x02`a\x03\x02\x02\x02a\v\x03\x02\x02\x02bd\x05"\x12\x02cb\x03\x02' +
1857
+ "\x02\x02cd\x03\x02\x02\x02df\x03\x02\x02\x02eg\x05 \x11\x02fe\x03\x02" +
1858
+ "\x02\x02fg\x03\x02\x02\x02gi\x03\x02\x02\x02hj\x05\x1A\x0E\x02ih\x03\x02" +
1859
+ "\x02\x02ij\x03\x02\x02\x02jl\x03\x02\x02\x02km\x05\x1C\x0F\x02lk\x03\x02" +
1860
+ "\x02\x02lm\x03\x02\x02\x02m\r\x03\x02\x02\x02no\x07\x0F\x02\x02op\x05" +
1861
+ '"\x12\x02p\x0F\x03\x02\x02\x02qv\x05\x12\n\x02rs\x07\x06\x02\x02su\x05' +
1862
+ "\x12\n\x02tr\x03\x02\x02\x02ux\x03\x02\x02\x02vt\x03\x02\x02\x02vw\x03" +
1863
+ "\x02\x02\x02w\x11\x03\x02\x02\x02xv\x03\x02\x02\x02yz\x05(\x15\x02z}\x07" +
1864
+ "\x12\x02\x02{~\x05$\x13\x02|~\x052\x1A\x02}{\x03\x02\x02\x02}|\x03\x02" +
1865
+ "\x02\x02~\x13\x03\x02\x02\x02\x7F\x84\x05\x16\f\x02\x80\x81\x07\x06\x02" +
1866
+ "\x02\x81\x83\x05\x16\f\x02\x82\x80\x03\x02\x02\x02\x83\x86\x03\x02\x02" +
1867
+ "\x02\x84\x82\x03\x02\x02\x02\x84\x85\x03\x02\x02\x02\x85\x15\x03\x02\x02" +
1868
+ "\x02\x86\x84\x03\x02\x02\x02\x87\x9E\x05(\x15\x02\x88\x89\x07(\x02\x02" +
1869
+ "\x89\x8A\x07\x04\x02\x02\x8A\x8B\x07-\x02\x02\x8B\x8C\x07\x05\x02\x02" +
1870
+ "\x8C\x8D\x07&\x02\x02\x8D\x9E\x05(\x15\x02\x8E\x8F\x07(\x02\x02\x8F\x90" +
1871
+ "\x07\x04\x02\x02\x90\x91\x07\'\x02\x02\x91\x92\x05(\x15\x02\x92\x93\x07" +
1872
+ "\x05\x02\x02\x93\x94\x07&\x02\x02\x94\x95\x05(\x15\x02\x95\x9E\x03\x02" +
1873
+ "\x02\x02\x96\x97\t\x02\x02\x02\x97\x98\x07\x04\x02\x02\x98\x99\x05(\x15" +
1874
+ "\x02\x99\x9A\x07\x05\x02\x02\x9A\x9B\x07&\x02\x02\x9B\x9C\x05(\x15\x02" +
1875
+ "\x9C\x9E\x03\x02\x02\x02\x9D\x87\x03\x02\x02\x02\x9D\x88\x03\x02\x02\x02" +
1876
+ "\x9D\x8E\x03\x02\x02\x02\x9D\x96\x03\x02\x02\x02\x9E\x17\x03\x02\x02\x02" +
1877
+ "\x9F\xA0\x07%\x02\x02\xA0\xA5\x05(\x15\x02\xA1\xA2\x07\x06\x02\x02\xA2" +
1878
+ "\xA4\x05(\x15\x02\xA3\xA1\x03\x02\x02\x02\xA4\xA7\x03\x02\x02\x02\xA5" +
1879
+ "\xA3\x03\x02\x02\x02\xA5\xA6\x03\x02\x02\x02\xA6\x19\x03\x02\x02\x02\xA7" +
1880
+ "\xA5\x03\x02\x02\x02\xA8\xAB\x07 \x02\x02\xA9\xAC\x05.\x18\x02\xAA\xAC" +
1881
+ "\x052\x1A\x02\xAB\xA9\x03\x02\x02\x02\xAB\xAA\x03\x02\x02\x02\xAC\x1B" +
1882
+ "\x03\x02\x02\x02\xAD\xB0\x07!\x02\x02\xAE\xB1\x05,\x17\x02\xAF\xB1\x05" +
1883
+ "2\x1A\x02\xB0\xAE\x03\x02\x02\x02\xB0\xAF\x03\x02\x02\x02\xB1\x1D\x03" +
1884
+ "\x02\x02\x02\xB2\xB4\x05(\x15\x02\xB3\xB5\t\x03\x02\x02\xB4\xB3\x03\x02" +
1885
+ '\x02\x02\xB4\xB5\x03\x02\x02\x02\xB5\x1F\x03\x02\x02\x02\xB6\xB7\x07"' +
1886
+ "\x02\x02\xB7\xBC\x05\x1E\x10\x02\xB8\xB9\x07\x06\x02\x02\xB9\xBB\x05\x1E" +
1887
+ "\x10\x02\xBA\xB8\x03\x02\x02\x02\xBB\xBE\x03\x02\x02\x02\xBC\xBA\x03\x02" +
1888
+ "\x02\x02\xBC\xBD\x03\x02\x02\x02\xBD!\x03\x02\x02\x02\xBE\xBC\x03\x02" +
1889
+ "\x02\x02\xBF\xC0\b\x12\x01\x02\xC0\xC1\x05(\x15\x02\xC1\xC4\x07\x18\x02" +
1890
+ "\x02\xC2\xC5\x05,\x17\x02\xC3\xC5\x052\x1A\x02\xC4\xC2\x03\x02\x02\x02" +
1891
+ "\xC4\xC3\x03\x02\x02\x02\xC5\xE7\x03\x02\x02\x02\xC6\xC7\x05(\x15\x02" +
1892
+ "\xC7\xCA\x07\x19\x02\x02\xC8\xCB\x054\x1B\x02\xC9\xCB\x052\x1A\x02\xCA" +
1893
+ "\xC8\x03\x02\x02\x02\xCA\xC9\x03\x02\x02\x02\xCB\xE7\x03\x02\x02\x02\xCC" +
1894
+ "\xCD\x05(\x15\x02\xCD\xD0\x07\x1A\x02\x02\xCE\xD1\x05,\x17\x02\xCF\xD1" +
1895
+ "\x052\x1A\x02\xD0\xCE\x03\x02\x02\x02\xD0\xCF\x03\x02\x02\x02\xD1\xE7" +
1896
+ "\x03\x02\x02\x02\xD2\xD3\x05(\x15\x02\xD3\xD4\x07\x1B\x02\x02\xD4\xD5" +
1897
+ "\x07\x1D\x02\x02\xD5\xE7\x03\x02\x02\x02\xD6\xD7\x05(\x15\x02\xD7\xD8" +
1898
+ "\x07\x1B\x02\x02\xD8\xD9\x07\x1C\x02\x02\xD9\xDA\x07\x1D\x02\x02\xDA\xE7" +
1899
+ "\x03\x02\x02\x02\xDB\xDC\x05(\x15\x02\xDC\xDF\t\x04\x02\x02\xDD\xE0\x05" +
1900
+ "$\x13\x02\xDE\xE0\x052\x1A\x02\xDF\xDD\x03\x02\x02\x02\xDF\xDE\x03\x02" +
1901
+ '\x02\x02\xE0\xE7\x03\x02\x02\x02\xE1\xE2\x07\x04\x02\x02\xE2\xE3\x05"' +
1902
+ "\x12\x02\xE3\xE4\x07\x05\x02\x02\xE4\xE7\x03\x02\x02\x02\xE5\xE7\x05&" +
1903
+ "\x14\x02\xE6\xBF\x03\x02\x02\x02\xE6\xC6\x03\x02\x02\x02\xE6\xCC\x03\x02" +
1904
+ "\x02\x02\xE6\xD2\x03\x02\x02\x02\xE6\xD6\x03\x02\x02\x02\xE6\xDB\x03\x02" +
1905
+ "\x02\x02\xE6\xE1\x03\x02\x02\x02\xE6\xE5\x03\x02\x02\x02\xE7\xF0\x03\x02" +
1906
+ '\x02\x02\xE8\xE9\f\x06\x02\x02\xE9\xEA\x07\x10\x02\x02\xEA\xEF\x05"\x12' +
1907
+ '\x07\xEB\xEC\f\x05\x02\x02\xEC\xED\x07\x11\x02\x02\xED\xEF\x05"\x12\x06' +
1908
+ "\xEE\xE8\x03\x02\x02\x02\xEE\xEB\x03\x02\x02\x02\xEF\xF2\x03\x02\x02\x02" +
1909
+ "\xF0\xEE\x03\x02\x02\x02\xF0\xF1\x03\x02\x02\x02\xF1#\x03\x02\x02\x02" +
1910
+ "\xF2\xF0\x03\x02\x02\x02\xF3\xF8\x05*\x16\x02\xF4\xF8\x05.\x18\x02\xF5" +
1911
+ "\xF8\x050\x19\x02\xF6\xF8\x05,\x17\x02\xF7\xF3\x03\x02\x02\x02\xF7\xF4" +
1912
+ "\x03\x02\x02\x02\xF7\xF5\x03\x02\x02\x02\xF7\xF6\x03\x02\x02\x02\xF8%" +
1913
+ "\x03\x02\x02\x02\xF9\xFC\x05$\x13\x02\xFA\xFC\x05(\x15\x02\xFB\xF9\x03" +
1914
+ "\x02\x02\x02\xFB\xFA\x03\x02\x02\x02\xFC\'\x03\x02\x02\x02\xFD\xFE\t\x05" +
1915
+ "\x02\x02\xFE)\x03\x02\x02\x02\xFF\u0100\t\x06\x02\x02\u0100+\x03\x02\x02" +
1916
+ "\x02\u0101\u0102\t\x07\x02\x02\u0102-\x03\x02\x02\x02\u0103\u0104\x07" +
1917
+ "0\x02\x02\u0104/\x03\x02\x02\x02\u0105\u0106\x071\x02\x02\u01061\x03\x02" +
1918
+ "\x02\x02\u0107\u0108\t\b\x02\x02\u01083\x03\x02\x02\x02\u0109\u010C\x07" +
1919
+ "\t\x02\x02\u010A\u010D\x05$\x13\x02\u010B\u010D\x052\x1A\x02\u010C\u010A" +
1920
+ "\x03\x02\x02\x02\u010C\u010B\x03\x02\x02\x02\u010D\u0115\x03\x02\x02\x02" +
1921
+ "\u010E\u0111\x07\x06\x02\x02\u010F\u0112\x05$\x13\x02\u0110\u0112\x05" +
1922
+ "2\x1A\x02\u0111\u010F\x03\x02\x02\x02\u0111\u0110\x03\x02\x02\x02\u0112" +
1923
+ "\u0114\x03\x02\x02\x02\u0113\u010E\x03\x02\x02\x02\u0114\u0117\x03\x02" +
1924
+ "\x02\x02\u0115\u0113\x03\x02\x02\x02\u0115\u0116\x03\x02\x02\x02\u0116" +
1925
+ "\u0118\x03\x02\x02\x02\u0117\u0115\x03\x02\x02\x02\u0118\u0119\x07\n\x02" +
1926
+ "\x02\u01195\x03\x02\x02\x02&8?CFLOTWZ]`cfilv}\x84\x9D\xA5\xAB\xB0\xB4" +
1927
+ "\xBC\xC4\xCA\xD0\xDF\xE6\xEE\xF0\xF7\xFB\u010C\u0111\u0115";
1928
+ static __ATN;
1929
+ static get _ATN() {
1930
+ if (!WebdaQLParserParser.__ATN) {
1931
+ WebdaQLParserParser.__ATN = new ATNDeserializer().deserialize(Utils.toCharArray(WebdaQLParserParser._serializedATN));
1932
+ }
1933
+ return WebdaQLParserParser.__ATN;
1934
+ }
1935
+ }
1936
+ export class WebdaqlContext extends ParserRuleContext {
1937
+ EOF() {
1938
+ return this.getToken(WebdaQLParserParser.EOF, 0);
1939
+ }
1940
+ statement() {
1941
+ return this.tryGetRuleContext(0, StatementContext);
1942
+ }
1943
+ filterQuery() {
1944
+ return this.tryGetRuleContext(0, FilterQueryContext);
1945
+ }
1946
+ constructor(parent, invokingState) {
1947
+ super(parent, invokingState);
1948
+ }
1949
+ // @Override
1950
+ get ruleIndex() {
1951
+ return WebdaQLParserParser.RULE_webdaql;
1952
+ }
1953
+ // @Override
1954
+ enterRule(listener) {
1955
+ if (listener.enterWebdaql) {
1956
+ listener.enterWebdaql(this);
1957
+ }
1958
+ }
1959
+ // @Override
1960
+ exitRule(listener) {
1961
+ if (listener.exitWebdaql) {
1962
+ listener.exitWebdaql(this);
1963
+ }
1964
+ }
1965
+ // @Override
1966
+ accept(visitor) {
1967
+ if (visitor.visitWebdaql) {
1968
+ return visitor.visitWebdaql(this);
1969
+ }
1970
+ else {
1971
+ return visitor.visitChildren(this);
1972
+ }
1973
+ }
1974
+ }
1975
+ export class StatementContext extends ParserRuleContext {
1976
+ deleteStatement() {
1977
+ return this.tryGetRuleContext(0, DeleteStatementContext);
1978
+ }
1979
+ updateStatement() {
1980
+ return this.tryGetRuleContext(0, UpdateStatementContext);
1981
+ }
1982
+ selectStatement() {
1983
+ return this.tryGetRuleContext(0, SelectStatementContext);
1984
+ }
1985
+ constructor(parent, invokingState) {
1986
+ super(parent, invokingState);
1987
+ }
1988
+ // @Override
1989
+ get ruleIndex() {
1990
+ return WebdaQLParserParser.RULE_statement;
1991
+ }
1992
+ // @Override
1993
+ enterRule(listener) {
1994
+ if (listener.enterStatement) {
1995
+ listener.enterStatement(this);
1996
+ }
1997
+ }
1998
+ // @Override
1999
+ exitRule(listener) {
2000
+ if (listener.exitStatement) {
2001
+ listener.exitStatement(this);
2002
+ }
2003
+ }
2004
+ // @Override
2005
+ accept(visitor) {
2006
+ if (visitor.visitStatement) {
2007
+ return visitor.visitStatement(this);
2008
+ }
2009
+ else {
2010
+ return visitor.visitChildren(this);
2011
+ }
2012
+ }
2013
+ }
2014
+ export class DeleteStatementContext extends ParserRuleContext {
2015
+ DELETE() {
2016
+ return this.getToken(WebdaQLParserParser.DELETE, 0);
2017
+ }
2018
+ whereClause() {
2019
+ return this.tryGetRuleContext(0, WhereClauseContext);
2020
+ }
2021
+ limitExpression() {
2022
+ return this.tryGetRuleContext(0, LimitExpressionContext);
2023
+ }
2024
+ constructor(parent, invokingState) {
2025
+ super(parent, invokingState);
2026
+ }
2027
+ // @Override
2028
+ get ruleIndex() {
2029
+ return WebdaQLParserParser.RULE_deleteStatement;
2030
+ }
2031
+ // @Override
2032
+ enterRule(listener) {
2033
+ if (listener.enterDeleteStatement) {
2034
+ listener.enterDeleteStatement(this);
2035
+ }
2036
+ }
2037
+ // @Override
2038
+ exitRule(listener) {
2039
+ if (listener.exitDeleteStatement) {
2040
+ listener.exitDeleteStatement(this);
2041
+ }
2042
+ }
2043
+ // @Override
2044
+ accept(visitor) {
2045
+ if (visitor.visitDeleteStatement) {
2046
+ return visitor.visitDeleteStatement(this);
2047
+ }
2048
+ else {
2049
+ return visitor.visitChildren(this);
2050
+ }
2051
+ }
2052
+ }
2053
+ export class UpdateStatementContext extends ParserRuleContext {
2054
+ UPDATE() {
2055
+ return this.getToken(WebdaQLParserParser.UPDATE, 0);
2056
+ }
2057
+ SET() {
2058
+ return this.getToken(WebdaQLParserParser.SET, 0);
2059
+ }
2060
+ assignmentList() {
2061
+ return this.getRuleContext(0, AssignmentListContext);
2062
+ }
2063
+ whereClause() {
2064
+ return this.tryGetRuleContext(0, WhereClauseContext);
2065
+ }
2066
+ limitExpression() {
2067
+ return this.tryGetRuleContext(0, LimitExpressionContext);
2068
+ }
2069
+ constructor(parent, invokingState) {
2070
+ super(parent, invokingState);
2071
+ }
2072
+ // @Override
2073
+ get ruleIndex() {
2074
+ return WebdaQLParserParser.RULE_updateStatement;
2075
+ }
2076
+ // @Override
2077
+ enterRule(listener) {
2078
+ if (listener.enterUpdateStatement) {
2079
+ listener.enterUpdateStatement(this);
2080
+ }
2081
+ }
2082
+ // @Override
2083
+ exitRule(listener) {
2084
+ if (listener.exitUpdateStatement) {
2085
+ listener.exitUpdateStatement(this);
2086
+ }
2087
+ }
2088
+ // @Override
2089
+ accept(visitor) {
2090
+ if (visitor.visitUpdateStatement) {
2091
+ return visitor.visitUpdateStatement(this);
2092
+ }
2093
+ else {
2094
+ return visitor.visitChildren(this);
2095
+ }
2096
+ }
2097
+ }
2098
+ export class SelectStatementContext extends ParserRuleContext {
2099
+ SELECT() {
2100
+ return this.getToken(WebdaQLParserParser.SELECT, 0);
2101
+ }
2102
+ fieldList() {
2103
+ return this.getRuleContext(0, FieldListContext);
2104
+ }
2105
+ whereClause() {
2106
+ return this.tryGetRuleContext(0, WhereClauseContext);
2107
+ }
2108
+ groupByExpression() {
2109
+ return this.tryGetRuleContext(0, GroupByExpressionContext);
2110
+ }
2111
+ orderExpression() {
2112
+ return this.tryGetRuleContext(0, OrderExpressionContext);
2113
+ }
2114
+ limitExpression() {
2115
+ return this.tryGetRuleContext(0, LimitExpressionContext);
2116
+ }
2117
+ offsetExpression() {
2118
+ return this.tryGetRuleContext(0, OffsetExpressionContext);
2119
+ }
2120
+ constructor(parent, invokingState) {
2121
+ super(parent, invokingState);
2122
+ }
2123
+ // @Override
2124
+ get ruleIndex() {
2125
+ return WebdaQLParserParser.RULE_selectStatement;
2126
+ }
2127
+ // @Override
2128
+ enterRule(listener) {
2129
+ if (listener.enterSelectStatement) {
2130
+ listener.enterSelectStatement(this);
2131
+ }
2132
+ }
2133
+ // @Override
2134
+ exitRule(listener) {
2135
+ if (listener.exitSelectStatement) {
2136
+ listener.exitSelectStatement(this);
2137
+ }
2138
+ }
2139
+ // @Override
2140
+ accept(visitor) {
2141
+ if (visitor.visitSelectStatement) {
2142
+ return visitor.visitSelectStatement(this);
2143
+ }
2144
+ else {
2145
+ return visitor.visitChildren(this);
2146
+ }
2147
+ }
2148
+ }
2149
+ export class FilterQueryContext extends ParserRuleContext {
2150
+ expression() {
2151
+ return this.tryGetRuleContext(0, ExpressionContext);
1228
2152
  }
1229
2153
  orderExpression() {
1230
2154
  return this.tryGetRuleContext(0, OrderExpressionContext);
1231
2155
  }
1232
- limitExpression() {
1233
- return this.tryGetRuleContext(0, LimitExpressionContext);
2156
+ limitExpression() {
2157
+ return this.tryGetRuleContext(0, LimitExpressionContext);
2158
+ }
2159
+ offsetExpression() {
2160
+ return this.tryGetRuleContext(0, OffsetExpressionContext);
2161
+ }
2162
+ constructor(parent, invokingState) {
2163
+ super(parent, invokingState);
2164
+ }
2165
+ // @Override
2166
+ get ruleIndex() {
2167
+ return WebdaQLParserParser.RULE_filterQuery;
2168
+ }
2169
+ // @Override
2170
+ enterRule(listener) {
2171
+ if (listener.enterFilterQuery) {
2172
+ listener.enterFilterQuery(this);
2173
+ }
2174
+ }
2175
+ // @Override
2176
+ exitRule(listener) {
2177
+ if (listener.exitFilterQuery) {
2178
+ listener.exitFilterQuery(this);
2179
+ }
2180
+ }
2181
+ // @Override
2182
+ accept(visitor) {
2183
+ if (visitor.visitFilterQuery) {
2184
+ return visitor.visitFilterQuery(this);
2185
+ }
2186
+ else {
2187
+ return visitor.visitChildren(this);
2188
+ }
2189
+ }
2190
+ }
2191
+ export class WhereClauseContext extends ParserRuleContext {
2192
+ WHERE() {
2193
+ return this.getToken(WebdaQLParserParser.WHERE, 0);
2194
+ }
2195
+ expression() {
2196
+ return this.getRuleContext(0, ExpressionContext);
2197
+ }
2198
+ constructor(parent, invokingState) {
2199
+ super(parent, invokingState);
2200
+ }
2201
+ // @Override
2202
+ get ruleIndex() {
2203
+ return WebdaQLParserParser.RULE_whereClause;
2204
+ }
2205
+ // @Override
2206
+ enterRule(listener) {
2207
+ if (listener.enterWhereClause) {
2208
+ listener.enterWhereClause(this);
2209
+ }
2210
+ }
2211
+ // @Override
2212
+ exitRule(listener) {
2213
+ if (listener.exitWhereClause) {
2214
+ listener.exitWhereClause(this);
2215
+ }
2216
+ }
2217
+ // @Override
2218
+ accept(visitor) {
2219
+ if (visitor.visitWhereClause) {
2220
+ return visitor.visitWhereClause(this);
2221
+ }
2222
+ else {
2223
+ return visitor.visitChildren(this);
2224
+ }
2225
+ }
2226
+ }
2227
+ export class AssignmentListContext extends ParserRuleContext {
2228
+ assignment(i) {
2229
+ if (i === undefined) {
2230
+ return this.getRuleContexts(AssignmentContext);
2231
+ }
2232
+ else {
2233
+ return this.getRuleContext(i, AssignmentContext);
2234
+ }
2235
+ }
2236
+ COMMA(i) {
2237
+ if (i === undefined) {
2238
+ return this.getTokens(WebdaQLParserParser.COMMA);
2239
+ }
2240
+ else {
2241
+ return this.getToken(WebdaQLParserParser.COMMA, i);
2242
+ }
2243
+ }
2244
+ constructor(parent, invokingState) {
2245
+ super(parent, invokingState);
1234
2246
  }
1235
- offsetExpression() {
1236
- return this.tryGetRuleContext(0, OffsetExpressionContext);
2247
+ // @Override
2248
+ get ruleIndex() {
2249
+ return WebdaQLParserParser.RULE_assignmentList;
2250
+ }
2251
+ // @Override
2252
+ enterRule(listener) {
2253
+ if (listener.enterAssignmentList) {
2254
+ listener.enterAssignmentList(this);
2255
+ }
2256
+ }
2257
+ // @Override
2258
+ exitRule(listener) {
2259
+ if (listener.exitAssignmentList) {
2260
+ listener.exitAssignmentList(this);
2261
+ }
2262
+ }
2263
+ // @Override
2264
+ accept(visitor) {
2265
+ if (visitor.visitAssignmentList) {
2266
+ return visitor.visitAssignmentList(this);
2267
+ }
2268
+ else {
2269
+ return visitor.visitChildren(this);
2270
+ }
2271
+ }
2272
+ }
2273
+ export class AssignmentContext extends ParserRuleContext {
2274
+ identifier() {
2275
+ return this.getRuleContext(0, IdentifierContext);
2276
+ }
2277
+ EQUAL() {
2278
+ return this.getToken(WebdaQLParserParser.EQUAL, 0);
2279
+ }
2280
+ values() {
2281
+ return this.tryGetRuleContext(0, ValuesContext);
2282
+ }
2283
+ parameter() {
2284
+ return this.tryGetRuleContext(0, ParameterContext);
1237
2285
  }
1238
2286
  constructor(parent, invokingState) {
1239
2287
  super(parent, invokingState);
1240
2288
  }
1241
2289
  // @Override
1242
2290
  get ruleIndex() {
1243
- return WebdaQLParserParser.RULE_webdaql;
2291
+ return WebdaQLParserParser.RULE_assignment;
1244
2292
  }
1245
2293
  // @Override
1246
2294
  enterRule(listener) {
1247
- if (listener.enterWebdaql) {
1248
- listener.enterWebdaql(this);
2295
+ if (listener.enterAssignment) {
2296
+ listener.enterAssignment(this);
1249
2297
  }
1250
2298
  }
1251
2299
  // @Override
1252
2300
  exitRule(listener) {
1253
- if (listener.exitWebdaql) {
1254
- listener.exitWebdaql(this);
2301
+ if (listener.exitAssignment) {
2302
+ listener.exitAssignment(this);
1255
2303
  }
1256
2304
  }
1257
2305
  // @Override
1258
2306
  accept(visitor) {
1259
- if (visitor.visitWebdaql) {
1260
- return visitor.visitWebdaql(this);
2307
+ if (visitor.visitAssignment) {
2308
+ return visitor.visitAssignment(this);
2309
+ }
2310
+ else {
2311
+ return visitor.visitChildren(this);
2312
+ }
2313
+ }
2314
+ }
2315
+ export class FieldListContext extends ParserRuleContext {
2316
+ selectItem(i) {
2317
+ if (i === undefined) {
2318
+ return this.getRuleContexts(SelectItemContext);
2319
+ }
2320
+ else {
2321
+ return this.getRuleContext(i, SelectItemContext);
2322
+ }
2323
+ }
2324
+ COMMA(i) {
2325
+ if (i === undefined) {
2326
+ return this.getTokens(WebdaQLParserParser.COMMA);
2327
+ }
2328
+ else {
2329
+ return this.getToken(WebdaQLParserParser.COMMA, i);
2330
+ }
2331
+ }
2332
+ constructor(parent, invokingState) {
2333
+ super(parent, invokingState);
2334
+ }
2335
+ // @Override
2336
+ get ruleIndex() {
2337
+ return WebdaQLParserParser.RULE_fieldList;
2338
+ }
2339
+ // @Override
2340
+ enterRule(listener) {
2341
+ if (listener.enterFieldList) {
2342
+ listener.enterFieldList(this);
2343
+ }
2344
+ }
2345
+ // @Override
2346
+ exitRule(listener) {
2347
+ if (listener.exitFieldList) {
2348
+ listener.exitFieldList(this);
2349
+ }
2350
+ }
2351
+ // @Override
2352
+ accept(visitor) {
2353
+ if (visitor.visitFieldList) {
2354
+ return visitor.visitFieldList(this);
2355
+ }
2356
+ else {
2357
+ return visitor.visitChildren(this);
2358
+ }
2359
+ }
2360
+ }
2361
+ export class SelectItemContext extends ParserRuleContext {
2362
+ constructor(parent, invokingState) {
2363
+ super(parent, invokingState);
2364
+ }
2365
+ // @Override
2366
+ get ruleIndex() {
2367
+ return WebdaQLParserParser.RULE_selectItem;
2368
+ }
2369
+ copyFrom(ctx) {
2370
+ super.copyFrom(ctx);
2371
+ }
2372
+ }
2373
+ export class FieldItemContext extends SelectItemContext {
2374
+ identifier() {
2375
+ return this.getRuleContext(0, IdentifierContext);
2376
+ }
2377
+ constructor(ctx) {
2378
+ super(ctx.parent, ctx.invokingState);
2379
+ this.copyFrom(ctx);
2380
+ }
2381
+ // @Override
2382
+ enterRule(listener) {
2383
+ if (listener.enterFieldItem) {
2384
+ listener.enterFieldItem(this);
2385
+ }
2386
+ }
2387
+ // @Override
2388
+ exitRule(listener) {
2389
+ if (listener.exitFieldItem) {
2390
+ listener.exitFieldItem(this);
2391
+ }
2392
+ }
2393
+ // @Override
2394
+ accept(visitor) {
2395
+ if (visitor.visitFieldItem) {
2396
+ return visitor.visitFieldItem(this);
2397
+ }
2398
+ else {
2399
+ return visitor.visitChildren(this);
2400
+ }
2401
+ }
2402
+ }
2403
+ export class CountAllItemContext extends SelectItemContext {
2404
+ COUNT() {
2405
+ return this.getToken(WebdaQLParserParser.COUNT, 0);
2406
+ }
2407
+ LR_BRACKET() {
2408
+ return this.getToken(WebdaQLParserParser.LR_BRACKET, 0);
2409
+ }
2410
+ STAR() {
2411
+ return this.getToken(WebdaQLParserParser.STAR, 0);
2412
+ }
2413
+ RR_BRACKET() {
2414
+ return this.getToken(WebdaQLParserParser.RR_BRACKET, 0);
2415
+ }
2416
+ AS() {
2417
+ return this.getToken(WebdaQLParserParser.AS, 0);
2418
+ }
2419
+ identifier() {
2420
+ return this.getRuleContext(0, IdentifierContext);
2421
+ }
2422
+ constructor(ctx) {
2423
+ super(ctx.parent, ctx.invokingState);
2424
+ this.copyFrom(ctx);
2425
+ }
2426
+ // @Override
2427
+ enterRule(listener) {
2428
+ if (listener.enterCountAllItem) {
2429
+ listener.enterCountAllItem(this);
2430
+ }
2431
+ }
2432
+ // @Override
2433
+ exitRule(listener) {
2434
+ if (listener.exitCountAllItem) {
2435
+ listener.exitCountAllItem(this);
2436
+ }
2437
+ }
2438
+ // @Override
2439
+ accept(visitor) {
2440
+ if (visitor.visitCountAllItem) {
2441
+ return visitor.visitCountAllItem(this);
2442
+ }
2443
+ else {
2444
+ return visitor.visitChildren(this);
2445
+ }
2446
+ }
2447
+ }
2448
+ export class CountDistinctItemContext extends SelectItemContext {
2449
+ COUNT() {
2450
+ return this.getToken(WebdaQLParserParser.COUNT, 0);
2451
+ }
2452
+ LR_BRACKET() {
2453
+ return this.getToken(WebdaQLParserParser.LR_BRACKET, 0);
2454
+ }
2455
+ DISTINCT() {
2456
+ return this.getToken(WebdaQLParserParser.DISTINCT, 0);
2457
+ }
2458
+ identifier(i) {
2459
+ if (i === undefined) {
2460
+ return this.getRuleContexts(IdentifierContext);
2461
+ }
2462
+ else {
2463
+ return this.getRuleContext(i, IdentifierContext);
2464
+ }
2465
+ }
2466
+ RR_BRACKET() {
2467
+ return this.getToken(WebdaQLParserParser.RR_BRACKET, 0);
2468
+ }
2469
+ AS() {
2470
+ return this.getToken(WebdaQLParserParser.AS, 0);
2471
+ }
2472
+ constructor(ctx) {
2473
+ super(ctx.parent, ctx.invokingState);
2474
+ this.copyFrom(ctx);
2475
+ }
2476
+ // @Override
2477
+ enterRule(listener) {
2478
+ if (listener.enterCountDistinctItem) {
2479
+ listener.enterCountDistinctItem(this);
2480
+ }
2481
+ }
2482
+ // @Override
2483
+ exitRule(listener) {
2484
+ if (listener.exitCountDistinctItem) {
2485
+ listener.exitCountDistinctItem(this);
2486
+ }
2487
+ }
2488
+ // @Override
2489
+ accept(visitor) {
2490
+ if (visitor.visitCountDistinctItem) {
2491
+ return visitor.visitCountDistinctItem(this);
2492
+ }
2493
+ else {
2494
+ return visitor.visitChildren(this);
2495
+ }
2496
+ }
2497
+ }
2498
+ export class MetricItemContext extends SelectItemContext {
2499
+ LR_BRACKET() {
2500
+ return this.getToken(WebdaQLParserParser.LR_BRACKET, 0);
2501
+ }
2502
+ identifier(i) {
2503
+ if (i === undefined) {
2504
+ return this.getRuleContexts(IdentifierContext);
2505
+ }
2506
+ else {
2507
+ return this.getRuleContext(i, IdentifierContext);
2508
+ }
2509
+ }
2510
+ RR_BRACKET() {
2511
+ return this.getToken(WebdaQLParserParser.RR_BRACKET, 0);
2512
+ }
2513
+ AS() {
2514
+ return this.getToken(WebdaQLParserParser.AS, 0);
2515
+ }
2516
+ COUNT() {
2517
+ return this.tryGetToken(WebdaQLParserParser.COUNT, 0);
2518
+ }
2519
+ SUM() {
2520
+ return this.tryGetToken(WebdaQLParserParser.SUM, 0);
2521
+ }
2522
+ AVG() {
2523
+ return this.tryGetToken(WebdaQLParserParser.AVG, 0);
2524
+ }
2525
+ MIN() {
2526
+ return this.tryGetToken(WebdaQLParserParser.MIN, 0);
2527
+ }
2528
+ MAX() {
2529
+ return this.tryGetToken(WebdaQLParserParser.MAX, 0);
2530
+ }
2531
+ constructor(ctx) {
2532
+ super(ctx.parent, ctx.invokingState);
2533
+ this.copyFrom(ctx);
2534
+ }
2535
+ // @Override
2536
+ enterRule(listener) {
2537
+ if (listener.enterMetricItem) {
2538
+ listener.enterMetricItem(this);
2539
+ }
2540
+ }
2541
+ // @Override
2542
+ exitRule(listener) {
2543
+ if (listener.exitMetricItem) {
2544
+ listener.exitMetricItem(this);
2545
+ }
2546
+ }
2547
+ // @Override
2548
+ accept(visitor) {
2549
+ if (visitor.visitMetricItem) {
2550
+ return visitor.visitMetricItem(this);
2551
+ }
2552
+ else {
2553
+ return visitor.visitChildren(this);
2554
+ }
2555
+ }
2556
+ }
2557
+ export class GroupByExpressionContext extends ParserRuleContext {
2558
+ GROUP_BY() {
2559
+ return this.getToken(WebdaQLParserParser.GROUP_BY, 0);
2560
+ }
2561
+ identifier(i) {
2562
+ if (i === undefined) {
2563
+ return this.getRuleContexts(IdentifierContext);
2564
+ }
2565
+ else {
2566
+ return this.getRuleContext(i, IdentifierContext);
2567
+ }
2568
+ }
2569
+ COMMA(i) {
2570
+ if (i === undefined) {
2571
+ return this.getTokens(WebdaQLParserParser.COMMA);
2572
+ }
2573
+ else {
2574
+ return this.getToken(WebdaQLParserParser.COMMA, i);
2575
+ }
2576
+ }
2577
+ constructor(parent, invokingState) {
2578
+ super(parent, invokingState);
2579
+ }
2580
+ // @Override
2581
+ get ruleIndex() {
2582
+ return WebdaQLParserParser.RULE_groupByExpression;
2583
+ }
2584
+ // @Override
2585
+ enterRule(listener) {
2586
+ if (listener.enterGroupByExpression) {
2587
+ listener.enterGroupByExpression(this);
2588
+ }
2589
+ }
2590
+ // @Override
2591
+ exitRule(listener) {
2592
+ if (listener.exitGroupByExpression) {
2593
+ listener.exitGroupByExpression(this);
2594
+ }
2595
+ }
2596
+ // @Override
2597
+ accept(visitor) {
2598
+ if (visitor.visitGroupByExpression) {
2599
+ return visitor.visitGroupByExpression(this);
1261
2600
  }
1262
2601
  else {
1263
2602
  return visitor.visitChildren(this);