vtlengine 1.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

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.

Potentially problematic release.

This version of vtlengine might be problematic. Click here for more details.

Files changed (54) hide show
  1. vtlengine/API/_InternalApi.py +153 -100
  2. vtlengine/API/__init__.py +109 -67
  3. vtlengine/AST/ASTConstructor.py +188 -98
  4. vtlengine/AST/ASTConstructorModules/Expr.py +306 -200
  5. vtlengine/AST/ASTConstructorModules/ExprComponents.py +172 -102
  6. vtlengine/AST/ASTConstructorModules/Terminals.py +158 -95
  7. vtlengine/AST/ASTEncoders.py +1 -1
  8. vtlengine/AST/ASTTemplate.py +8 -9
  9. vtlengine/AST/ASTVisitor.py +8 -12
  10. vtlengine/AST/DAG/__init__.py +43 -35
  11. vtlengine/AST/DAG/_words.py +4 -4
  12. vtlengine/AST/Grammar/lexer.py +732 -142
  13. vtlengine/AST/Grammar/parser.py +2188 -826
  14. vtlengine/AST/Grammar/tokens.py +128 -128
  15. vtlengine/AST/VtlVisitor.py +7 -4
  16. vtlengine/AST/__init__.py +22 -11
  17. vtlengine/DataTypes/NumericTypesHandling.py +5 -4
  18. vtlengine/DataTypes/TimeHandling.py +194 -301
  19. vtlengine/DataTypes/__init__.py +304 -218
  20. vtlengine/Exceptions/__init__.py +52 -27
  21. vtlengine/Exceptions/messages.py +134 -62
  22. vtlengine/Interpreter/__init__.py +781 -487
  23. vtlengine/Model/__init__.py +165 -121
  24. vtlengine/Operators/Aggregation.py +156 -95
  25. vtlengine/Operators/Analytic.py +115 -59
  26. vtlengine/Operators/Assignment.py +7 -4
  27. vtlengine/Operators/Boolean.py +27 -32
  28. vtlengine/Operators/CastOperator.py +177 -131
  29. vtlengine/Operators/Clause.py +137 -99
  30. vtlengine/Operators/Comparison.py +148 -117
  31. vtlengine/Operators/Conditional.py +149 -98
  32. vtlengine/Operators/General.py +68 -47
  33. vtlengine/Operators/HROperators.py +91 -72
  34. vtlengine/Operators/Join.py +217 -118
  35. vtlengine/Operators/Numeric.py +89 -44
  36. vtlengine/Operators/RoleSetter.py +16 -15
  37. vtlengine/Operators/Set.py +61 -36
  38. vtlengine/Operators/String.py +213 -139
  39. vtlengine/Operators/Time.py +334 -216
  40. vtlengine/Operators/Validation.py +117 -76
  41. vtlengine/Operators/__init__.py +340 -213
  42. vtlengine/Utils/__init__.py +195 -40
  43. vtlengine/__init__.py +1 -1
  44. vtlengine/files/output/__init__.py +15 -6
  45. vtlengine/files/output/_time_period_representation.py +10 -9
  46. vtlengine/files/parser/__init__.py +77 -52
  47. vtlengine/files/parser/_rfc_dialect.py +6 -5
  48. vtlengine/files/parser/_time_checking.py +46 -37
  49. vtlengine-1.0.1.dist-info/METADATA +236 -0
  50. vtlengine-1.0.1.dist-info/RECORD +58 -0
  51. {vtlengine-1.0.dist-info → vtlengine-1.0.1.dist-info}/WHEEL +1 -1
  52. vtlengine-1.0.dist-info/METADATA +0 -104
  53. vtlengine-1.0.dist-info/RECORD +0 -58
  54. {vtlengine-1.0.dist-info → vtlengine-1.0.1.dist-info}/LICENSE.md +0 -0
vtlengine/AST/Grammar/parser.py CHANGED
@@ -19,8 +19,8 @@ def serializedATN():
19
19
  buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
20
20
  buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
21
21
  buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
22
- buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
23
- buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
22
+ buf.write('\4\37\t\37\4 \t \4!\t!\4"\t"\4#\t#\4$\t$\4%\t%\4&\t')
23
+ buf.write("&\4'\t'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
24
24
  buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
25
25
  buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
26
26
  buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
@@ -111,7 +111,7 @@ def serializedATN():
111
111
  buf.write(" \3 \3 \5 \u03eb\n \3 \5 \u03ee\n \3 \5 \u03f1\n \3 \5")
112
112
  buf.write(" \u03f4\n \3 \3 \3 \3 \3 \3 \5 \u03fc\n \3 \5 \u03ff\n")
113
113
  buf.write(" \3 \5 \u0402\n \3 \5 \u0405\n \3 \3 \5 \u0409\n \3!\3")
114
- buf.write("!\3!\3!\3!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3#\3#\3#")
114
+ buf.write('!\3!\3!\3!\3!\3!\3"\3"\3"\3"\3"\3"\3"\3#\3#\3#')
115
115
  buf.write("\3#\3#\3#\3#\3#\5#\u0421\n#\3$\3$\3$\3$\3$\5$\u0428\n")
116
116
  buf.write("$\5$\u042a\n$\3$\3$\3%\3%\3%\3%\3%\3%\5%\u0434\n%\3%\5")
117
117
  buf.write("%\u0437\n%\3%\5%\u043a\n%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3")
@@ -121,7 +121,7 @@ def serializedATN():
121
121
  buf.write("&\3&\3&\3&\3&\3&\3&\3&\3&\5&\u0476\n&\5&\u0478\n&\3&\3")
122
122
  buf.write("&\3&\5&\u047d\n&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\5&\u0489")
123
123
  buf.write("\n&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\5&\u0499")
124
- buf.write("\n&\3\'\3\'\3\'\3\'\3(\3(\3(\7(\u04a2\n(\f(\16(\u04a5")
124
+ buf.write("\n&\3'\3'\3'\3'\3(\3(\3(\7(\u04a2\n(\f(\16(\u04a5")
125
125
  buf.write("\13(\3)\5)\u04a8\n)\3)\3)\3)\3)\3*\5*\u04af\n*\3*\3*\3")
126
126
  buf.write("*\3*\3+\3+\3+\3+\3,\3,\3,\3,\3,\3,\3,\3,\5,\u04c1\n,\3")
127
127
  buf.write(",\3,\5,\u04c5\n,\3-\3-\3-\7-\u04ca\n-\f-\16-\u04cd\13")
@@ -164,14 +164,14 @@ def serializedATN():
164
164
  buf.write("\13a\3a\3a\3b\3b\3b\3c\3c\3c\3d\3d\3e\3e\5e\u0687\ne\3")
165
165
  buf.write("f\3f\5f\u068b\nf\3g\3g\3g\3g\3g\5g\u0692\ng\3h\3h\3h\3")
166
166
  buf.write("i\3i\3j\3j\3k\3k\3l\3l\3m\3m\3n\3n\3n\2\4\6\bo\2\4\6\b")
167
- buf.write("\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668")
167
+ buf.write('\n\f\16\20\22\24\26\30\32\34\36 "$&(*,.\60\62\64\668')
168
168
  buf.write(":<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084")
169
169
  buf.write("\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096")
170
170
  buf.write("\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8")
171
171
  buf.write("\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba")
172
172
  buf.write("\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc")
173
- buf.write("\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\2\'\4\2\17")
174
- buf.write("\20))\3\2\21\22\4\2\17\20TT\3\2\'(\3\2+,\3\2 !\4\2\u00c0")
173
+ buf.write("\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\2'\4\2\17")
174
+ buf.write("\20))\3\2\21\22\4\2\17\20TT\3\2'(\3\2+,\3\2 !\4\2\u00c0")
175
175
  buf.write("\u00c0\u00c2\u00c2\3\2\u00b7\u00b8\3\2\u00b9\u00ba\5\2")
176
176
  buf.write("SSUWyz\6\2KKMMbb}\177\3\2OP\4\2NNQR\4\2>>\u00c7\u00c7")
177
177
  buf.write("\3\2\u0098\u0099\4\2ii\u00ea\u00ea\3\2HI\4\2\62\62\u0081")
@@ -186,7 +186,7 @@ def serializedATN():
186
186
  buf.write("\3\2\2\2\16\u0174\3\2\2\2\20\u0176\3\2\2\2\22\u017f\3")
187
187
  buf.write("\2\2\2\24\u0187\3\2\2\2\26\u018a\3\2\2\2\30\u0193\3\2")
188
188
  buf.write("\2\2\32\u019c\3\2\2\2\34\u01a1\3\2\2\2\36\u01b6\3\2\2")
189
- buf.write("\2 \u01ea\3\2\2\2\"\u0225\3\2\2\2$\u0260\3\2\2\2&\u0264")
189
+ buf.write('\2 \u01ea\3\2\2\2"\u0225\3\2\2\2$\u0260\3\2\2\2&\u0264')
190
190
  buf.write("\3\2\2\2(\u0268\3\2\2\2*\u029a\3\2\2\2,\u02cc\3\2\2\2")
191
191
  buf.write(".\u02e3\3\2\2\2\60\u02fa\3\2\2\2\62\u031c\3\2\2\2\64\u0333")
192
192
  buf.write("\3\2\2\2\66\u0363\3\2\2\28\u0393\3\2\2\2:\u03b2\3\2\2")
@@ -273,12 +273,12 @@ def serializedATN():
273
273
  buf.write("\u0154\3\2\2\2\u0152\u0150\3\2\2\2\u0152\u0153\3\2\2\2")
274
274
  buf.write("\u0153\t\3\2\2\2\u0154\u0152\3\2\2\2\u0155\u015e\5$\23")
275
275
  buf.write("\2\u0156\u015e\5,\27\2\u0157\u015e\5\60\31\2\u0158\u015e")
276
- buf.write("\5\64\33\2\u0159\u015e\58\35\2\u015a\u015e\5B\"\2\u015b")
276
+ buf.write('\5\64\33\2\u0159\u015e\58\35\2\u015a\u015e\5B"\2\u015b')
277
277
  buf.write("\u015e\5D#\2\u015c\u015e\5J&\2\u015d\u0155\3\2\2\2\u015d")
278
278
  buf.write("\u0156\3\2\2\2\u015d\u0157\3\2\2\2\u015d\u0158\3\2\2\2")
279
279
  buf.write("\u015d\u0159\3\2\2\2\u015d\u015a\3\2\2\2\u015d\u015b\3")
280
280
  buf.write("\2\2\2\u015d\u015c\3\2\2\2\u015e\13\3\2\2\2\u015f\u016c")
281
- buf.write("\5\36\20\2\u0160\u016c\5\"\22\2\u0161\u016c\5*\26\2\u0162")
281
+ buf.write('\5\36\20\2\u0160\u016c\5"\22\2\u0161\u016c\5*\26\2\u0162')
282
282
  buf.write("\u016c\5.\30\2\u0163\u016c\5\62\32\2\u0164\u016c\5\66")
283
283
  buf.write("\34\2\u0165\u016c\5:\36\2\u0166\u016c\5<\37\2\u0167\u016c")
284
284
  buf.write("\5> \2\u0168\u016c\5@!\2\u0169\u016c\5F$\2\u016a\u016c")
@@ -293,14 +293,14 @@ def serializedATN():
293
293
  buf.write("\u016e\3\2\2\2\u0174\u016f\3\2\2\2\u0174\u0170\3\2\2\2")
294
294
  buf.write("\u0174\u0171\3\2\2\2\u0174\u0172\3\2\2\2\u0174\u0173\3")
295
295
  buf.write("\2\2\2\u0175\17\3\2\2\2\u0176\u0177\7$\2\2\u0177\u017c")
296
- buf.write("\5L\'\2\u0178\u0179\7\23\2\2\u0179\u017b\5L\'\2\u017a")
296
+ buf.write("\5L'\2\u0178\u0179\7\23\2\2\u0179\u017b\5L'\2\u017a")
297
297
  buf.write("\u0178\3\2\2\2\u017b\u017e\3\2\2\2\u017c\u017a\3\2\2\2")
298
298
  buf.write("\u017c\u017d\3\2\2\2\u017d\21\3\2\2\2\u017e\u017c\3\2")
299
299
  buf.write("\2\2\u017f\u0180\7?\2\2\u0180\u0185\5N(\2\u0181\u0183")
300
300
  buf.write("\5n8\2\u0182\u0184\5p9\2\u0183\u0182\3\2\2\2\u0183\u0184")
301
301
  buf.write("\3\2\2\2\u0184\u0186\3\2\2\2\u0185\u0181\3\2\2\2\u0185")
302
302
  buf.write("\u0186\3\2\2\2\u0186\23\3\2\2\2\u0187\u0188\7`\2\2\u0188")
303
- buf.write("\u0189\5\b\5\2\u0189\25\3\2\2\2\u018a\u018b\7\"\2\2\u018b")
303
+ buf.write('\u0189\5\b\5\2\u0189\25\3\2\2\2\u018a\u018b\7"\2\2\u018b')
304
304
  buf.write("\u0190\5R*\2\u018c\u018d\7\23\2\2\u018d\u018f\5R*\2\u018e")
305
305
  buf.write("\u018c\3\2\2\2\u018f\u0192\3\2\2\2\u0190\u018e\3\2\2\2")
306
306
  buf.write("\u0190\u0191\3\2\2\2\u0191\27\3\2\2\2\u0192\u0190\3\2")
@@ -393,7 +393,7 @@ def serializedATN():
393
393
  buf.write("\u025f\u0261\3\2\2\2\u0260\u0227\3\2\2\2\u0260\u0235\3")
394
394
  buf.write("\2\2\2\u0260\u0243\3\2\2\2\u0261%\3\2\2\2\u0262\u0265")
395
395
  buf.write("\5\b\5\2\u0263\u0265\7i\2\2\u0264\u0262\3\2\2\2\u0264")
396
- buf.write("\u0263\3\2\2\2\u0265\'\3\2\2\2\u0266\u0269\5\6\4\2\u0267")
396
+ buf.write("\u0263\3\2\2\2\u0265'\3\2\2\2\u0266\u0269\5\6\4\2\u0267")
397
397
  buf.write("\u0269\7i\2\2\u0268\u0266\3\2\2\2\u0268\u0267\3\2\2\2")
398
398
  buf.write("\u0269)\3\2\2\2\u026a\u026b\t\13\2\2\u026b\u026c\7\3\2")
399
399
  buf.write("\2\u026c\u026d\5\6\4\2\u026d\u026e\7\4\2\2\u026e\u029b")
@@ -838,7 +838,7 @@ def serializedATN():
838
838
  buf.write("\3\2\2\2\u065b\u00af\3\2\2\2\u065c\u065a\3\2\2\2\u065d")
839
839
  buf.write("\u065e\t \2\2\u065e\u00b1\3\2\2\2\u065f\u0660\7<\2\2\u0660")
840
840
  buf.write("\u0661\5\6\4\2\u0661\u00b3\3\2\2\2\u0662\u0663\t!\2\2")
841
- buf.write("\u0663\u00b5\3\2\2\2\u0664\u0665\t\"\2\2\u0665\u00b7\3")
841
+ buf.write('\u0663\u00b5\3\2\2\2\u0664\u0665\t"\2\2\u0665\u00b7\3')
842
842
  buf.write("\2\2\2\u0666\u0667\7\u00eb\2\2\u0667\u00b9\3\2\2\2\u0668")
843
843
  buf.write("\u0669\7\u00eb\2\2\u0669\u00bb\3\2\2\2\u066a\u066b\7\u00eb")
844
844
  buf.write("\2\2\u066b\u00bd\3\2\2\2\u066c\u066f\7\u00eb\2\2\u066d")
@@ -898,105 +898,485 @@ class Parser(Parser):
898
898
 
899
899
  sharedContextCache = PredictionContextCache()
900
900
 
901
- literalNames = ["<INVALID>", "'('", "')'", "'['", "']'", "'{'", "'}'",
902
- "'='", "'<'", "'>'", "'>='", "'<>'", "'<='", "'+'",
903
- "'-'", "'*'", "'/'", "','", "'->'", "':'", "':='",
904
- "'#'", "'eval'", "'if'", "'then'", "'else'", "'using'",
905
- "'with'", "'current_date'", "'on'", "'drop'", "'keep'",
906
- "'calc'", "'attrcalc'", "'rename'", "'as'", "'and'",
907
- "'or'", "'xor'", "'not'", "'between'", "'in'", "'not_in'",
908
- "'null'", "'isnull'", "'ex'", "'union'", "'diff'",
909
- "'symdiff'", "'intersect'", "'keys'", "'intyear'",
910
- "'intmonth'", "'intday'", "'check'", "'exists_in'",
911
- "'to'", "'return'", "'imbalance'", "'errorcode'", "'all'",
912
- "'aggr'", "'errorlevel'", "'order'", "'by'", "'rank'",
913
- "'asc'", "'desc'", "'min'", "'max'", "'first'", "'last'",
914
- "'indexof'", "'abs'", "'key'", "'ln'", "'log'", "'trunc'",
915
- "'round'", "'power'", "'mod'", "'length'", "'||'",
916
- "'trim'", "'upper'", "'lower'", "'substr'", "'sum'",
917
- "'avg'", "'median'", "'count'", "'identifier'", "'measure'",
918
- "'attribute'", "'filter'", "'merge'", "'exp'", "'componentRole'",
919
- "'viral'", "'match_characters'", "'type'", "'nvl'",
920
- "'hierarchy'", "'_'", "'invalid'", "'valuedomain'",
921
- "'variable'", "'data'", "'structure'", "'dataset'",
922
- "'operator'", "'define'", "'<-'", "'datapoint'", "'hierarchical'",
923
- "'ruleset'", "'rule'", "'end'", "'alterDataset'", "'ltrim'",
924
- "'rtrim'", "'instr'", "'replace'", "'ceil'", "'floor'",
925
- "'sqrt'", "'any'", "'setdiff'", "'stddev_pop'", "'stddev_samp'",
926
- "'var_pop'", "'var_samp'", "'group'", "'except'", "'having'",
927
- "'first_value'", "'last_value'", "'lag'", "'lead'",
928
- "'ratio_to_report'", "'over'", "'preceding'", "'following'",
929
- "'unbounded'", "'partition'", "'rows'", "'range'",
930
- "'current'", "'valid'", "'fill_time_series'", "'flow_to_stock'",
931
- "'stock_to_flow'", "'timeshift'", "'measures'", "'no_measures'",
932
- "'condition'", "'boolean'", "'date'", "'time_period'",
933
- "'number'", "'string'", "'time'", "'integer'", "'float'",
934
- "'list'", "'record'", "'restrict'", "'yyyy'", "'mm'",
935
- "'dd'", "'maxLength'", "'regexp'", "'is'", "'when'",
936
- "'from'", "'aggregates'", "'points'", "'point'", "'total'",
937
- "'partial'", "'always'", "'inner_join'", "'left_join'",
938
- "'cross_join'", "'full_join'", "'maps_from'", "'maps_to'",
939
- "'map_to'", "'map_from'", "'returns'", "'pivot'", "'customPivot'",
940
- "'unpivot'", "'sub'", "'apply'", "'conditioned'", "'period_indicator'",
941
- "'single'", "'duration'", "'time_agg'", "'unit'", "'Value'",
942
- "'valuedomains'", "'variables'", "'input'", "'output'",
943
- "'cast'", "'rule_priority'", "'dataset_priority'",
944
- "'default'", "'check_datapoint'", "'check_hierarchy'",
945
- "'computed'", "'non_null'", "'non_zero'", "'partial_null'",
946
- "'partial_zero'", "'always_null'", "'always_zero'",
947
- "'components'", "'all_measures'", "'scalar'", "'component'",
948
- "'datapoint_on_valuedomains'", "'datapoint_on_variables'",
949
- "'hierarchical_on_valuedomains'", "'hierarchical_on_variables'",
950
- "'set'", "'language'", "<INVALID>", "<INVALID>", "<INVALID>",
951
- "<INVALID>", "<INVALID>", "<INVALID>", "';'"]
952
-
953
- symbolicNames = ["<INVALID>", "LPAREN", "RPAREN", "QLPAREN", "QRPAREN",
954
- "GLPAREN", "GRPAREN", "EQ", "LT", "MT", "ME", "NEQ",
955
- "LE", "PLUS", "MINUS", "MUL", "DIV", "COMMA", "POINTER",
956
- "COLON", "ASSIGN", "MEMBERSHIP", "EVAL", "IF", "THEN",
957
- "ELSE", "USING", "WITH", "CURRENT_DATE", "ON", "DROP",
958
- "KEEP", "CALC", "ATTRCALC", "RENAME", "AS", "AND",
959
- "OR", "XOR", "NOT", "BETWEEN", "IN", "NOT_IN", "NULL_CONSTANT",
960
- "ISNULL", "EX", "UNION", "DIFF", "SYMDIFF", "INTERSECT",
961
- "KEYS", "INTYEAR", "INTMONTH", "INTDAY", "CHECK",
962
- "EXISTS_IN", "TO", "RETURN", "IMBALANCE", "ERRORCODE",
963
- "ALL", "AGGREGATE", "ERRORLEVEL", "ORDER", "BY", "RANK",
964
- "ASC", "DESC", "MIN", "MAX", "FIRST", "LAST", "INDEXOF",
965
- "ABS", "KEY", "LN", "LOG", "TRUNC", "ROUND", "POWER",
966
- "MOD", "LEN", "CONCAT", "TRIM", "UCASE", "LCASE",
967
- "SUBSTR", "SUM", "AVG", "MEDIAN", "COUNT", "DIMENSION",
968
- "MEASURE", "ATTRIBUTE", "FILTER", "MERGE", "EXP",
969
- "ROLE", "VIRAL", "CHARSET_MATCH", "TYPE", "NVL", "HIERARCHY",
970
- "OPTIONAL", "INVALID", "VALUE_DOMAIN", "VARIABLE",
971
- "DATA", "STRUCTURE", "DATASET", "OPERATOR", "DEFINE",
972
- "PUT_SYMBOL", "DATAPOINT", "HIERARCHICAL", "RULESET",
973
- "RULE", "END", "ALTER_DATASET", "LTRIM", "RTRIM",
974
- "INSTR", "REPLACE", "CEIL", "FLOOR", "SQRT", "ANY",
975
- "SETDIFF", "STDDEV_POP", "STDDEV_SAMP", "VAR_POP",
976
- "VAR_SAMP", "GROUP", "EXCEPT", "HAVING", "FIRST_VALUE",
977
- "LAST_VALUE", "LAG", "LEAD", "RATIO_TO_REPORT", "OVER",
978
- "PRECEDING", "FOLLOWING", "UNBOUNDED", "PARTITION",
979
- "ROWS", "RANGE", "CURRENT", "VALID", "FILL_TIME_SERIES",
980
- "FLOW_TO_STOCK", "STOCK_TO_FLOW", "TIMESHIFT", "MEASURES",
981
- "NO_MEASURES", "CONDITION", "BOOLEAN", "DATE", "TIME_PERIOD",
982
- "NUMBER", "STRING", "TIME", "INTEGER", "FLOAT", "LIST",
983
- "RECORD", "RESTRICT", "YYYY", "MM", "DD", "MAX_LENGTH",
984
- "REGEXP", "IS", "WHEN", "FROM", "AGGREGATES", "POINTS",
985
- "POINT", "TOTAL", "PARTIAL", "ALWAYS", "INNER_JOIN",
986
- "LEFT_JOIN", "CROSS_JOIN", "FULL_JOIN", "MAPS_FROM",
987
- "MAPS_TO", "MAP_TO", "MAP_FROM", "RETURNS", "PIVOT",
988
- "CUSTOMPIVOT", "UNPIVOT", "SUBSPACE", "APPLY", "CONDITIONED",
989
- "PERIOD_INDICATOR", "SINGLE", "DURATION", "TIME_AGG",
990
- "UNIT", "VALUE", "VALUEDOMAINS", "VARIABLES", "INPUT",
991
- "OUTPUT", "CAST", "RULE_PRIORITY", "DATASET_PRIORITY",
992
- "DEFAULT", "CHECK_DATAPOINT", "CHECK_HIERARCHY", "COMPUTED",
993
- "NON_NULL", "NON_ZERO", "PARTIAL_NULL", "PARTIAL_ZERO",
994
- "ALWAYS_NULL", "ALWAYS_ZERO", "COMPONENTS", "ALL_MEASURES",
995
- "SCALAR", "COMPONENT", "DATAPOINT_ON_VD", "DATAPOINT_ON_VAR",
996
- "HIERARCHICAL_ON_VD", "HIERARCHICAL_ON_VAR", "SET",
997
- "LANGUAGE", "INTEGER_CONSTANT", "NUMBER_CONSTANT",
998
- "BOOLEAN_CONSTANT", "STRING_CONSTANT", "IDENTIFIER",
999
- "WS", "EOL", "ML_COMMENT", "SL_COMMENT"]
901
+ literalNames = [
902
+ "<INVALID>",
903
+ "'('",
904
+ "')'",
905
+ "'['",
906
+ "']'",
907
+ "'{'",
908
+ "'}'",
909
+ "'='",
910
+ "'<'",
911
+ "'>'",
912
+ "'>='",
913
+ "'<>'",
914
+ "'<='",
915
+ "'+'",
916
+ "'-'",
917
+ "'*'",
918
+ "'/'",
919
+ "','",
920
+ "'->'",
921
+ "':'",
922
+ "':='",
923
+ "'#'",
924
+ "'eval'",
925
+ "'if'",
926
+ "'then'",
927
+ "'else'",
928
+ "'using'",
929
+ "'with'",
930
+ "'current_date'",
931
+ "'on'",
932
+ "'drop'",
933
+ "'keep'",
934
+ "'calc'",
935
+ "'attrcalc'",
936
+ "'rename'",
937
+ "'as'",
938
+ "'and'",
939
+ "'or'",
940
+ "'xor'",
941
+ "'not'",
942
+ "'between'",
943
+ "'in'",
944
+ "'not_in'",
945
+ "'null'",
946
+ "'isnull'",
947
+ "'ex'",
948
+ "'union'",
949
+ "'diff'",
950
+ "'symdiff'",
951
+ "'intersect'",
952
+ "'keys'",
953
+ "'intyear'",
954
+ "'intmonth'",
955
+ "'intday'",
956
+ "'check'",
957
+ "'exists_in'",
958
+ "'to'",
959
+ "'return'",
960
+ "'imbalance'",
961
+ "'errorcode'",
962
+ "'all'",
963
+ "'aggr'",
964
+ "'errorlevel'",
965
+ "'order'",
966
+ "'by'",
967
+ "'rank'",
968
+ "'asc'",
969
+ "'desc'",
970
+ "'min'",
971
+ "'max'",
972
+ "'first'",
973
+ "'last'",
974
+ "'indexof'",
975
+ "'abs'",
976
+ "'key'",
977
+ "'ln'",
978
+ "'log'",
979
+ "'trunc'",
980
+ "'round'",
981
+ "'power'",
982
+ "'mod'",
983
+ "'length'",
984
+ "'||'",
985
+ "'trim'",
986
+ "'upper'",
987
+ "'lower'",
988
+ "'substr'",
989
+ "'sum'",
990
+ "'avg'",
991
+ "'median'",
992
+ "'count'",
993
+ "'identifier'",
994
+ "'measure'",
995
+ "'attribute'",
996
+ "'filter'",
997
+ "'merge'",
998
+ "'exp'",
999
+ "'componentRole'",
1000
+ "'viral'",
1001
+ "'match_characters'",
1002
+ "'type'",
1003
+ "'nvl'",
1004
+ "'hierarchy'",
1005
+ "'_'",
1006
+ "'invalid'",
1007
+ "'valuedomain'",
1008
+ "'variable'",
1009
+ "'data'",
1010
+ "'structure'",
1011
+ "'dataset'",
1012
+ "'operator'",
1013
+ "'define'",
1014
+ "'<-'",
1015
+ "'datapoint'",
1016
+ "'hierarchical'",
1017
+ "'ruleset'",
1018
+ "'rule'",
1019
+ "'end'",
1020
+ "'alterDataset'",
1021
+ "'ltrim'",
1022
+ "'rtrim'",
1023
+ "'instr'",
1024
+ "'replace'",
1025
+ "'ceil'",
1026
+ "'floor'",
1027
+ "'sqrt'",
1028
+ "'any'",
1029
+ "'setdiff'",
1030
+ "'stddev_pop'",
1031
+ "'stddev_samp'",
1032
+ "'var_pop'",
1033
+ "'var_samp'",
1034
+ "'group'",
1035
+ "'except'",
1036
+ "'having'",
1037
+ "'first_value'",
1038
+ "'last_value'",
1039
+ "'lag'",
1040
+ "'lead'",
1041
+ "'ratio_to_report'",
1042
+ "'over'",
1043
+ "'preceding'",
1044
+ "'following'",
1045
+ "'unbounded'",
1046
+ "'partition'",
1047
+ "'rows'",
1048
+ "'range'",
1049
+ "'current'",
1050
+ "'valid'",
1051
+ "'fill_time_series'",
1052
+ "'flow_to_stock'",
1053
+ "'stock_to_flow'",
1054
+ "'timeshift'",
1055
+ "'measures'",
1056
+ "'no_measures'",
1057
+ "'condition'",
1058
+ "'boolean'",
1059
+ "'date'",
1060
+ "'time_period'",
1061
+ "'number'",
1062
+ "'string'",
1063
+ "'time'",
1064
+ "'integer'",
1065
+ "'float'",
1066
+ "'list'",
1067
+ "'record'",
1068
+ "'restrict'",
1069
+ "'yyyy'",
1070
+ "'mm'",
1071
+ "'dd'",
1072
+ "'maxLength'",
1073
+ "'regexp'",
1074
+ "'is'",
1075
+ "'when'",
1076
+ "'from'",
1077
+ "'aggregates'",
1078
+ "'points'",
1079
+ "'point'",
1080
+ "'total'",
1081
+ "'partial'",
1082
+ "'always'",
1083
+ "'inner_join'",
1084
+ "'left_join'",
1085
+ "'cross_join'",
1086
+ "'full_join'",
1087
+ "'maps_from'",
1088
+ "'maps_to'",
1089
+ "'map_to'",
1090
+ "'map_from'",
1091
+ "'returns'",
1092
+ "'pivot'",
1093
+ "'customPivot'",
1094
+ "'unpivot'",
1095
+ "'sub'",
1096
+ "'apply'",
1097
+ "'conditioned'",
1098
+ "'period_indicator'",
1099
+ "'single'",
1100
+ "'duration'",
1101
+ "'time_agg'",
1102
+ "'unit'",
1103
+ "'Value'",
1104
+ "'valuedomains'",
1105
+ "'variables'",
1106
+ "'input'",
1107
+ "'output'",
1108
+ "'cast'",
1109
+ "'rule_priority'",
1110
+ "'dataset_priority'",
1111
+ "'default'",
1112
+ "'check_datapoint'",
1113
+ "'check_hierarchy'",
1114
+ "'computed'",
1115
+ "'non_null'",
1116
+ "'non_zero'",
1117
+ "'partial_null'",
1118
+ "'partial_zero'",
1119
+ "'always_null'",
1120
+ "'always_zero'",
1121
+ "'components'",
1122
+ "'all_measures'",
1123
+ "'scalar'",
1124
+ "'component'",
1125
+ "'datapoint_on_valuedomains'",
1126
+ "'datapoint_on_variables'",
1127
+ "'hierarchical_on_valuedomains'",
1128
+ "'hierarchical_on_variables'",
1129
+ "'set'",
1130
+ "'language'",
1131
+ "<INVALID>",
1132
+ "<INVALID>",
1133
+ "<INVALID>",
1134
+ "<INVALID>",
1135
+ "<INVALID>",
1136
+ "<INVALID>",
1137
+ "';'",
1138
+ ]
1139
+
1140
+ symbolicNames = [
1141
+ "<INVALID>",
1142
+ "LPAREN",
1143
+ "RPAREN",
1144
+ "QLPAREN",
1145
+ "QRPAREN",
1146
+ "GLPAREN",
1147
+ "GRPAREN",
1148
+ "EQ",
1149
+ "LT",
1150
+ "MT",
1151
+ "ME",
1152
+ "NEQ",
1153
+ "LE",
1154
+ "PLUS",
1155
+ "MINUS",
1156
+ "MUL",
1157
+ "DIV",
1158
+ "COMMA",
1159
+ "POINTER",
1160
+ "COLON",
1161
+ "ASSIGN",
1162
+ "MEMBERSHIP",
1163
+ "EVAL",
1164
+ "IF",
1165
+ "THEN",
1166
+ "ELSE",
1167
+ "USING",
1168
+ "WITH",
1169
+ "CURRENT_DATE",
1170
+ "ON",
1171
+ "DROP",
1172
+ "KEEP",
1173
+ "CALC",
1174
+ "ATTRCALC",
1175
+ "RENAME",
1176
+ "AS",
1177
+ "AND",
1178
+ "OR",
1179
+ "XOR",
1180
+ "NOT",
1181
+ "BETWEEN",
1182
+ "IN",
1183
+ "NOT_IN",
1184
+ "NULL_CONSTANT",
1185
+ "ISNULL",
1186
+ "EX",
1187
+ "UNION",
1188
+ "DIFF",
1189
+ "SYMDIFF",
1190
+ "INTERSECT",
1191
+ "KEYS",
1192
+ "INTYEAR",
1193
+ "INTMONTH",
1194
+ "INTDAY",
1195
+ "CHECK",
1196
+ "EXISTS_IN",
1197
+ "TO",
1198
+ "RETURN",
1199
+ "IMBALANCE",
1200
+ "ERRORCODE",
1201
+ "ALL",
1202
+ "AGGREGATE",
1203
+ "ERRORLEVEL",
1204
+ "ORDER",
1205
+ "BY",
1206
+ "RANK",
1207
+ "ASC",
1208
+ "DESC",
1209
+ "MIN",
1210
+ "MAX",
1211
+ "FIRST",
1212
+ "LAST",
1213
+ "INDEXOF",
1214
+ "ABS",
1215
+ "KEY",
1216
+ "LN",
1217
+ "LOG",
1218
+ "TRUNC",
1219
+ "ROUND",
1220
+ "POWER",
1221
+ "MOD",
1222
+ "LEN",
1223
+ "CONCAT",
1224
+ "TRIM",
1225
+ "UCASE",
1226
+ "LCASE",
1227
+ "SUBSTR",
1228
+ "SUM",
1229
+ "AVG",
1230
+ "MEDIAN",
1231
+ "COUNT",
1232
+ "DIMENSION",
1233
+ "MEASURE",
1234
+ "ATTRIBUTE",
1235
+ "FILTER",
1236
+ "MERGE",
1237
+ "EXP",
1238
+ "ROLE",
1239
+ "VIRAL",
1240
+ "CHARSET_MATCH",
1241
+ "TYPE",
1242
+ "NVL",
1243
+ "HIERARCHY",
1244
+ "OPTIONAL",
1245
+ "INVALID",
1246
+ "VALUE_DOMAIN",
1247
+ "VARIABLE",
1248
+ "DATA",
1249
+ "STRUCTURE",
1250
+ "DATASET",
1251
+ "OPERATOR",
1252
+ "DEFINE",
1253
+ "PUT_SYMBOL",
1254
+ "DATAPOINT",
1255
+ "HIERARCHICAL",
1256
+ "RULESET",
1257
+ "RULE",
1258
+ "END",
1259
+ "ALTER_DATASET",
1260
+ "LTRIM",
1261
+ "RTRIM",
1262
+ "INSTR",
1263
+ "REPLACE",
1264
+ "CEIL",
1265
+ "FLOOR",
1266
+ "SQRT",
1267
+ "ANY",
1268
+ "SETDIFF",
1269
+ "STDDEV_POP",
1270
+ "STDDEV_SAMP",
1271
+ "VAR_POP",
1272
+ "VAR_SAMP",
1273
+ "GROUP",
1274
+ "EXCEPT",
1275
+ "HAVING",
1276
+ "FIRST_VALUE",
1277
+ "LAST_VALUE",
1278
+ "LAG",
1279
+ "LEAD",
1280
+ "RATIO_TO_REPORT",
1281
+ "OVER",
1282
+ "PRECEDING",
1283
+ "FOLLOWING",
1284
+ "UNBOUNDED",
1285
+ "PARTITION",
1286
+ "ROWS",
1287
+ "RANGE",
1288
+ "CURRENT",
1289
+ "VALID",
1290
+ "FILL_TIME_SERIES",
1291
+ "FLOW_TO_STOCK",
1292
+ "STOCK_TO_FLOW",
1293
+ "TIMESHIFT",
1294
+ "MEASURES",
1295
+ "NO_MEASURES",
1296
+ "CONDITION",
1297
+ "BOOLEAN",
1298
+ "DATE",
1299
+ "TIME_PERIOD",
1300
+ "NUMBER",
1301
+ "STRING",
1302
+ "TIME",
1303
+ "INTEGER",
1304
+ "FLOAT",
1305
+ "LIST",
1306
+ "RECORD",
1307
+ "RESTRICT",
1308
+ "YYYY",
1309
+ "MM",
1310
+ "DD",
1311
+ "MAX_LENGTH",
1312
+ "REGEXP",
1313
+ "IS",
1314
+ "WHEN",
1315
+ "FROM",
1316
+ "AGGREGATES",
1317
+ "POINTS",
1318
+ "POINT",
1319
+ "TOTAL",
1320
+ "PARTIAL",
1321
+ "ALWAYS",
1322
+ "INNER_JOIN",
1323
+ "LEFT_JOIN",
1324
+ "CROSS_JOIN",
1325
+ "FULL_JOIN",
1326
+ "MAPS_FROM",
1327
+ "MAPS_TO",
1328
+ "MAP_TO",
1329
+ "MAP_FROM",
1330
+ "RETURNS",
1331
+ "PIVOT",
1332
+ "CUSTOMPIVOT",
1333
+ "UNPIVOT",
1334
+ "SUBSPACE",
1335
+ "APPLY",
1336
+ "CONDITIONED",
1337
+ "PERIOD_INDICATOR",
1338
+ "SINGLE",
1339
+ "DURATION",
1340
+ "TIME_AGG",
1341
+ "UNIT",
1342
+ "VALUE",
1343
+ "VALUEDOMAINS",
1344
+ "VARIABLES",
1345
+ "INPUT",
1346
+ "OUTPUT",
1347
+ "CAST",
1348
+ "RULE_PRIORITY",
1349
+ "DATASET_PRIORITY",
1350
+ "DEFAULT",
1351
+ "CHECK_DATAPOINT",
1352
+ "CHECK_HIERARCHY",
1353
+ "COMPUTED",
1354
+ "NON_NULL",
1355
+ "NON_ZERO",
1356
+ "PARTIAL_NULL",
1357
+ "PARTIAL_ZERO",
1358
+ "ALWAYS_NULL",
1359
+ "ALWAYS_ZERO",
1360
+ "COMPONENTS",
1361
+ "ALL_MEASURES",
1362
+ "SCALAR",
1363
+ "COMPONENT",
1364
+ "DATAPOINT_ON_VD",
1365
+ "DATAPOINT_ON_VAR",
1366
+ "HIERARCHICAL_ON_VD",
1367
+ "HIERARCHICAL_ON_VAR",
1368
+ "SET",
1369
+ "LANGUAGE",
1370
+ "INTEGER_CONSTANT",
1371
+ "NUMBER_CONSTANT",
1372
+ "BOOLEAN_CONSTANT",
1373
+ "STRING_CONSTANT",
1374
+ "IDENTIFIER",
1375
+ "WS",
1376
+ "EOL",
1377
+ "ML_COMMENT",
1378
+ "SL_COMMENT",
1379
+ ]
1000
1380
 
1001
1381
  RULE_start = 0
1002
1382
  RULE_statement = 1
@@ -1108,38 +1488,117 @@ class Parser(Parser):
1108
1488
  RULE_basicScalarType = 107
1109
1489
  RULE_retainType = 108
1110
1490
 
1111
- ruleNames = ["start", "statement", "expr", "exprComponent", "functionsComponents",
1112
- "functions", "datasetClause", "renameClause", "aggrClause",
1113
- "filterClause", "calcClause", "keepOrDropClause", "pivotOrUnpivotClause",
1114
- "subspaceClause", "joinOperators", "defOperators", "genericOperators",
1115
- "genericOperatorsComponent", "parameterComponent", "parameter",
1116
- "stringOperators", "stringOperatorsComponent", "numericOperators",
1117
- "numericOperatorsComponent", "comparisonOperators", "comparisonOperatorsComponent",
1118
- "timeOperators", "timeOperatorsComponent", "setOperators",
1119
- "hierarchyOperators", "validationOperators", "conditionalOperators",
1120
- "conditionalOperatorsComponent", "aggrOperators", "aggrOperatorsGrouping",
1121
- "anFunction", "anFunctionComponent", "renameClauseItem",
1122
- "aggregateClause", "aggrFunctionClause", "calcClauseItem",
1123
- "subspaceClauseItem", "scalarItem", "joinClauseWithoutUsing",
1124
- "joinClause", "joinClauseItem", "joinBody", "joinApplyClause",
1125
- "partitionByClause", "orderByClause", "orderByItem",
1126
- "windowingClause", "signedInteger", "limitClauseItem",
1127
- "groupingClause", "havingClause", "parameterItem", "outputParameterType",
1128
- "outputParameterTypeComponent", "inputParameterType",
1129
- "rulesetType", "scalarType", "componentType", "datasetType",
1130
- "evalDatasetType", "scalarSetType", "dpRuleset", "hrRuleset",
1131
- "valueDomainName", "rulesetID", "rulesetSignature", "signature",
1132
- "ruleClauseDatapoint", "ruleItemDatapoint", "ruleClauseHierarchical",
1133
- "ruleItemHierarchical", "hierRuleSignature", "valueDomainSignature",
1134
- "codeItemRelation", "codeItemRelationClause", "valueDomainValue",
1135
- "scalarTypeConstraint", "compConstraint", "multModifier",
1136
- "validationOutput", "validationMode", "conditionClause",
1137
- "inputMode", "imbalanceExpr", "inputModeHierarchy", "outputModeHierarchy",
1138
- "alias", "varID", "simpleComponentId", "componentID",
1139
- "lists", "erCode", "erLevel", "comparisonOperand", "optionalExpr",
1140
- "optionalExprComponent", "componentRole", "viralAttribute",
1141
- "valueDomainID", "operatorID", "routineName", "constant",
1142
- "basicScalarType", "retainType"]
1491
+ ruleNames = [
1492
+ "start",
1493
+ "statement",
1494
+ "expr",
1495
+ "exprComponent",
1496
+ "functionsComponents",
1497
+ "functions",
1498
+ "datasetClause",
1499
+ "renameClause",
1500
+ "aggrClause",
1501
+ "filterClause",
1502
+ "calcClause",
1503
+ "keepOrDropClause",
1504
+ "pivotOrUnpivotClause",
1505
+ "subspaceClause",
1506
+ "joinOperators",
1507
+ "defOperators",
1508
+ "genericOperators",
1509
+ "genericOperatorsComponent",
1510
+ "parameterComponent",
1511
+ "parameter",
1512
+ "stringOperators",
1513
+ "stringOperatorsComponent",
1514
+ "numericOperators",
1515
+ "numericOperatorsComponent",
1516
+ "comparisonOperators",
1517
+ "comparisonOperatorsComponent",
1518
+ "timeOperators",
1519
+ "timeOperatorsComponent",
1520
+ "setOperators",
1521
+ "hierarchyOperators",
1522
+ "validationOperators",
1523
+ "conditionalOperators",
1524
+ "conditionalOperatorsComponent",
1525
+ "aggrOperators",
1526
+ "aggrOperatorsGrouping",
1527
+ "anFunction",
1528
+ "anFunctionComponent",
1529
+ "renameClauseItem",
1530
+ "aggregateClause",
1531
+ "aggrFunctionClause",
1532
+ "calcClauseItem",
1533
+ "subspaceClauseItem",
1534
+ "scalarItem",
1535
+ "joinClauseWithoutUsing",
1536
+ "joinClause",
1537
+ "joinClauseItem",
1538
+ "joinBody",
1539
+ "joinApplyClause",
1540
+ "partitionByClause",
1541
+ "orderByClause",
1542
+ "orderByItem",
1543
+ "windowingClause",
1544
+ "signedInteger",
1545
+ "limitClauseItem",
1546
+ "groupingClause",
1547
+ "havingClause",
1548
+ "parameterItem",
1549
+ "outputParameterType",
1550
+ "outputParameterTypeComponent",
1551
+ "inputParameterType",
1552
+ "rulesetType",
1553
+ "scalarType",
1554
+ "componentType",
1555
+ "datasetType",
1556
+ "evalDatasetType",
1557
+ "scalarSetType",
1558
+ "dpRuleset",
1559
+ "hrRuleset",
1560
+ "valueDomainName",
1561
+ "rulesetID",
1562
+ "rulesetSignature",
1563
+ "signature",
1564
+ "ruleClauseDatapoint",
1565
+ "ruleItemDatapoint",
1566
+ "ruleClauseHierarchical",
1567
+ "ruleItemHierarchical",
1568
+ "hierRuleSignature",
1569
+ "valueDomainSignature",
1570
+ "codeItemRelation",
1571
+ "codeItemRelationClause",
1572
+ "valueDomainValue",
1573
+ "scalarTypeConstraint",
1574
+ "compConstraint",
1575
+ "multModifier",
1576
+ "validationOutput",
1577
+ "validationMode",
1578
+ "conditionClause",
1579
+ "inputMode",
1580
+ "imbalanceExpr",
1581
+ "inputModeHierarchy",
1582
+ "outputModeHierarchy",
1583
+ "alias",
1584
+ "varID",
1585
+ "simpleComponentId",
1586
+ "componentID",
1587
+ "lists",
1588
+ "erCode",
1589
+ "erLevel",
1590
+ "comparisonOperand",
1591
+ "optionalExpr",
1592
+ "optionalExprComponent",
1593
+ "componentRole",
1594
+ "viralAttribute",
1595
+ "valueDomainID",
1596
+ "operatorID",
1597
+ "routineName",
1598
+ "constant",
1599
+ "basicScalarType",
1600
+ "retainType",
1601
+ ]
1143
1602
 
1144
1603
  EOF = Token.EOF
1145
1604
  LPAREN = 1
@@ -1382,8 +1841,9 @@ class Parser(Parser):
1382
1841
 
1383
1842
  def __init__(self, input: TokenStream, output: TextIO = sys.stdout):
1384
1843
  super().__init__(input, output)
1385
- self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA,
1386
- self.sharedContextCache)
1844
+ self._interp = ParserATNSimulator(
1845
+ self, self.atn, self.decisionsToDFA, self.sharedContextCache
1846
+ )
1387
1847
  self._predicates = None
1388
1848
 
1389
1849
  class StartContext(ParserRuleContext):
@@ -1416,7 +1876,7 @@ class Parser(Parser):
1416
1876
  else:
1417
1877
  return visitor.visitChildren(self)
1418
1878
 
1419
- def start(self):
1879
+ def start(self) -> StartContext:
1420
1880
 
1421
1881
  localctx = Parser.StartContext(self, self._ctx, self.state)
1422
1882
  self.enterRule(localctx, 0, self.RULE_start)
@@ -1551,7 +2011,6 @@ class Parser(Parser):
1551
2011
  self.defOperators()
1552
2012
  pass
1553
2013
 
1554
-
1555
2014
  except RecognitionException as re:
1556
2015
  localctx.exception = re
1557
2016
  self._errHandler.reportError(self, re)
@@ -1922,8 +2381,16 @@ class Parser(Parser):
1922
2381
  self.state = 245
1923
2382
  localctx.op = self._input.LT(1)
1924
2383
  _la = self._input.LA(1)
1925
- if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & (
1926
- (1 << Parser.PLUS) | (1 << Parser.MINUS) | (1 << Parser.NOT))) != 0)):
2384
+ if not (
2385
+ (
2386
+ ((_la) & ~0x3F) == 0
2387
+ and (
2388
+ (1 << _la)
2389
+ & ((1 << Parser.PLUS) | (1 << Parser.MINUS) | (1 << Parser.NOT))
2390
+ )
2391
+ != 0
2392
+ )
2393
+ ):
1927
2394
  localctx.op = self._errHandler.recoverInline(self)
1928
2395
  else:
1929
2396
  self._errHandler.reportMatch(self)
@@ -1979,14 +2446,15 @@ class Parser(Parser):
1979
2446
  self._errHandler.sync(self)
1980
2447
  la_ = self._interp.adaptivePredict(self._input, 4, self._ctx)
1981
2448
  if la_ == 1:
1982
- localctx = Parser.ArithmeticExprContext(self,
1983
- Parser.ExprContext(self, _parentctx,
1984
- _parentState))
2449
+ localctx = Parser.ArithmeticExprContext(
2450
+ self, Parser.ExprContext(self, _parentctx, _parentState)
2451
+ )
1985
2452
  localctx.left = _prevctx
1986
2453
  self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
1987
2454
  self.state = 258
1988
2455
  if not self.precpred(self._ctx, 9):
1989
2456
  from antlr4.error.Errors import FailedPredicateException
2457
+
1990
2458
  raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
1991
2459
  self.state = 259
1992
2460
  localctx.op = self._input.LT(1)
@@ -2001,15 +2469,15 @@ class Parser(Parser):
2001
2469
  pass
2002
2470
 
2003
2471
  elif la_ == 2:
2004
- localctx = Parser.ArithmeticExprOrConcatContext(self,
2005
- Parser.ExprContext(self,
2006
- _parentctx,
2007
- _parentState))
2472
+ localctx = Parser.ArithmeticExprOrConcatContext(
2473
+ self, Parser.ExprContext(self, _parentctx, _parentState)
2474
+ )
2008
2475
  localctx.left = _prevctx
2009
2476
  self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
2010
2477
  self.state = 261
2011
2478
  if not self.precpred(self._ctx, 8):
2012
2479
  from antlr4.error.Errors import FailedPredicateException
2480
+
2013
2481
  raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
2014
2482
  self.state = 262
2015
2483
  localctx.op = self._input.LT(1)
@@ -2024,14 +2492,15 @@ class Parser(Parser):
2024
2492
  pass
2025
2493
 
2026
2494
  elif la_ == 3:
2027
- localctx = Parser.ComparisonExprContext(self,
2028
- Parser.ExprContext(self, _parentctx,
2029
- _parentState))
2495
+ localctx = Parser.ComparisonExprContext(
2496
+ self, Parser.ExprContext(self, _parentctx, _parentState)
2497
+ )
2030
2498
  localctx.left = _prevctx
2031
2499
  self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
2032
2500
  self.state = 264
2033
2501
  if not self.precpred(self._ctx, 7):
2034
2502
  from antlr4.error.Errors import FailedPredicateException
2503
+
2035
2504
  raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
2036
2505
  self.state = 265
2037
2506
  localctx.op = self.comparisonOperand()
@@ -2040,14 +2509,15 @@ class Parser(Parser):
2040
2509
  pass
2041
2510
 
2042
2511
  elif la_ == 4:
2043
- localctx = Parser.BooleanExprContext(self,
2044
- Parser.ExprContext(self, _parentctx,
2045
- _parentState))
2512
+ localctx = Parser.BooleanExprContext(
2513
+ self, Parser.ExprContext(self, _parentctx, _parentState)
2514
+ )
2046
2515
  localctx.left = _prevctx
2047
2516
  self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
2048
2517
  self.state = 268
2049
2518
  if not self.precpred(self._ctx, 5):
2050
2519
  from antlr4.error.Errors import FailedPredicateException
2520
+
2051
2521
  raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
2052
2522
  self.state = 269
2053
2523
  localctx.op = self.match(Parser.AND)
@@ -2056,14 +2526,15 @@ class Parser(Parser):
2056
2526
  pass
2057
2527
 
2058
2528
  elif la_ == 5:
2059
- localctx = Parser.BooleanExprContext(self,
2060
- Parser.ExprContext(self, _parentctx,
2061
- _parentState))
2529
+ localctx = Parser.BooleanExprContext(
2530
+ self, Parser.ExprContext(self, _parentctx, _parentState)
2531
+ )
2062
2532
  localctx.left = _prevctx
2063
2533
  self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
2064
2534
  self.state = 271
2065
2535
  if not self.precpred(self._ctx, 4):
2066
2536
  from antlr4.error.Errors import FailedPredicateException
2537
+
2067
2538
  raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
2068
2539
  self.state = 272
2069
2540
  localctx.op = self._input.LT(1)
@@ -2078,14 +2549,15 @@ class Parser(Parser):
2078
2549
  pass
2079
2550
 
2080
2551
  elif la_ == 6:
2081
- localctx = Parser.ClauseExprContext(self,
2082
- Parser.ExprContext(self, _parentctx,
2083
- _parentState))
2552
+ localctx = Parser.ClauseExprContext(
2553
+ self, Parser.ExprContext(self, _parentctx, _parentState)
2554
+ )
2084
2555
  localctx.dataset = _prevctx
2085
2556
  self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
2086
2557
  self.state = 274
2087
2558
  if not self.precpred(self._ctx, 12):
2088
2559
  from antlr4.error.Errors import FailedPredicateException
2560
+
2089
2561
  raise FailedPredicateException(self, "self.precpred(self._ctx, 12)")
2090
2562
  self.state = 275
2091
2563
  self.match(Parser.QLPAREN)
@@ -2096,13 +2568,14 @@ class Parser(Parser):
2096
2568
  pass
2097
2569
 
2098
2570
  elif la_ == 7:
2099
- localctx = Parser.MembershipExprContext(self,
2100
- Parser.ExprContext(self, _parentctx,
2101
- _parentState))
2571
+ localctx = Parser.MembershipExprContext(
2572
+ self, Parser.ExprContext(self, _parentctx, _parentState)
2573
+ )
2102
2574
  self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
2103
2575
  self.state = 279
2104
2576
  if not self.precpred(self._ctx, 11):
2105
2577
  from antlr4.error.Errors import FailedPredicateException
2578
+
2106
2579
  raise FailedPredicateException(self, "self.precpred(self._ctx, 11)")
2107
2580
  self.state = 280
2108
2581
  self.match(Parser.MEMBERSHIP)
@@ -2111,14 +2584,15 @@ class Parser(Parser):
2111
2584
  pass
2112
2585
 
2113
2586
  elif la_ == 8:
2114
- localctx = Parser.InNotInExprContext(self,
2115
- Parser.ExprContext(self, _parentctx,
2116
- _parentState))
2587
+ localctx = Parser.InNotInExprContext(
2588
+ self, Parser.ExprContext(self, _parentctx, _parentState)
2589
+ )
2117
2590
  localctx.left = _prevctx
2118
2591
  self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
2119
2592
  self.state = 282
2120
2593
  if not self.precpred(self._ctx, 6):
2121
2594
  from antlr4.error.Errors import FailedPredicateException
2595
+
2122
2596
  raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
2123
2597
  self.state = 283
2124
2598
  localctx.op = self._input.LT(1)
@@ -2170,8 +2644,9 @@ class Parser(Parser):
2170
2644
 
2171
2645
  class ArithmeticExprCompContext(ExprComponentContext):
2172
2646
 
2173
- def __init__(self, parser,
2174
- ctx: ParserRuleContext): # actually a VtlParser.ExprComponentContext
2647
+ def __init__(
2648
+ self, parser, ctx: ParserRuleContext
2649
+ ): # actually a VtlParser.ExprComponentContext
2175
2650
  super().__init__(parser)
2176
2651
  self.left = None # ExprComponentContext
2177
2652
  self.op = None # Token
@@ -2198,8 +2673,9 @@ class Parser(Parser):
2198
2673
 
2199
2674
  class IfExprCompContext(ExprComponentContext):
2200
2675
 
2201
- def __init__(self, parser,
2202
- ctx: ParserRuleContext): # actually a VtlParser.ExprComponentContext
2676
+ def __init__(
2677
+ self, parser, ctx: ParserRuleContext
2678
+ ): # actually a VtlParser.ExprComponentContext
2203
2679
  super().__init__(parser)
2204
2680
  self.conditionalExpr = None # ExprComponentContext
2205
2681
  self.thenExpr = None # ExprComponentContext
@@ -2229,8 +2705,9 @@ class Parser(Parser):
2229
2705
 
2230
2706
  class ComparisonExprCompContext(ExprComponentContext):
2231
2707
 
2232
- def __init__(self, parser,
2233
- ctx: ParserRuleContext): # actually a VtlParser.ExprComponentContext
2708
+ def __init__(
2709
+ self, parser, ctx: ParserRuleContext
2710
+ ): # actually a VtlParser.ExprComponentContext
2234
2711
  super().__init__(parser)
2235
2712
  self.left = None # ExprComponentContext
2236
2713
  self.right = None # ExprComponentContext
@@ -2253,8 +2730,9 @@ class Parser(Parser):
2253
2730
 
2254
2731
  class FunctionsExpressionCompContext(ExprComponentContext):
2255
2732
 
2256
- def __init__(self, parser,
2257
- ctx: ParserRuleContext): # actually a VtlParser.ExprComponentContext
2733
+ def __init__(
2734
+ self, parser, ctx: ParserRuleContext
2735
+ ): # actually a VtlParser.ExprComponentContext
2258
2736
  super().__init__(parser)
2259
2737
  self.copyFrom(ctx)
2260
2738
 
@@ -2269,8 +2747,9 @@ class Parser(Parser):
2269
2747
 
2270
2748
  class CompIdContext(ExprComponentContext):
2271
2749
 
2272
- def __init__(self, parser,
2273
- ctx: ParserRuleContext): # actually a VtlParser.ExprComponentContext
2750
+ def __init__(
2751
+ self, parser, ctx: ParserRuleContext
2752
+ ): # actually a VtlParser.ExprComponentContext
2274
2753
  super().__init__(parser)
2275
2754
  self.copyFrom(ctx)
2276
2755
 
@@ -2285,8 +2764,9 @@ class Parser(Parser):
2285
2764
 
2286
2765
  class ConstantExprCompContext(ExprComponentContext):
2287
2766
 
2288
- def __init__(self, parser,
2289
- ctx: ParserRuleContext): # actually a VtlParser.ExprComponentContext
2767
+ def __init__(
2768
+ self, parser, ctx: ParserRuleContext
2769
+ ): # actually a VtlParser.ExprComponentContext
2290
2770
  super().__init__(parser)
2291
2771
  self.copyFrom(ctx)
2292
2772
 
@@ -2301,8 +2781,9 @@ class Parser(Parser):
2301
2781
 
2302
2782
  class ArithmeticExprOrConcatCompContext(ExprComponentContext):
2303
2783
 
2304
- def __init__(self, parser,
2305
- ctx: ParserRuleContext): # actually a VtlParser.ExprComponentContext
2784
+ def __init__(
2785
+ self, parser, ctx: ParserRuleContext
2786
+ ): # actually a VtlParser.ExprComponentContext
2306
2787
  super().__init__(parser)
2307
2788
  self.left = None # ExprComponentContext
2308
2789
  self.op = None # Token
@@ -2332,8 +2813,9 @@ class Parser(Parser):
2332
2813
 
2333
2814
  class ParenthesisExprCompContext(ExprComponentContext):
2334
2815
 
2335
- def __init__(self, parser,
2336
- ctx: ParserRuleContext): # actually a VtlParser.ExprComponentContext
2816
+ def __init__(
2817
+ self, parser, ctx: ParserRuleContext
2818
+ ): # actually a VtlParser.ExprComponentContext
2337
2819
  super().__init__(parser)
2338
2820
  self.copyFrom(ctx)
2339
2821
 
@@ -2354,8 +2836,9 @@ class Parser(Parser):
2354
2836
 
2355
2837
  class InNotInExprCompContext(ExprComponentContext):
2356
2838
 
2357
- def __init__(self, parser,
2358
- ctx: ParserRuleContext): # actually a VtlParser.ExprComponentContext
2839
+ def __init__(
2840
+ self, parser, ctx: ParserRuleContext
2841
+ ): # actually a VtlParser.ExprComponentContext
2359
2842
  super().__init__(parser)
2360
2843
  self.left = None # ExprComponentContext
2361
2844
  self.op = None # Token
@@ -2384,8 +2867,9 @@ class Parser(Parser):
2384
2867
 
2385
2868
  class UnaryExprCompContext(ExprComponentContext):
2386
2869
 
2387
- def __init__(self, parser,
2388
- ctx: ParserRuleContext): # actually a VtlParser.ExprComponentContext
2870
+ def __init__(
2871
+ self, parser, ctx: ParserRuleContext
2872
+ ): # actually a VtlParser.ExprComponentContext
2389
2873
  super().__init__(parser)
2390
2874
  self.op = None # Token
2391
2875
  self.right = None # ExprComponentContext
@@ -2411,8 +2895,9 @@ class Parser(Parser):
2411
2895
 
2412
2896
  class BooleanExprCompContext(ExprComponentContext):
2413
2897
 
2414
- def __init__(self, parser,
2415
- ctx: ParserRuleContext): # actually a VtlParser.ExprComponentContext
2898
+ def __init__(
2899
+ self, parser, ctx: ParserRuleContext
2900
+ ): # actually a VtlParser.ExprComponentContext
2416
2901
  super().__init__(parser)
2417
2902
  self.left = None # ExprComponentContext
2418
2903
  self.op = None # Token
@@ -2481,8 +2966,16 @@ class Parser(Parser):
2481
2966
  self.state = 299
2482
2967
  localctx.op = self._input.LT(1)
2483
2968
  _la = self._input.LA(1)
2484
- if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & (
2485
- (1 << Parser.PLUS) | (1 << Parser.MINUS) | (1 << Parser.NOT))) != 0)):
2969
+ if not (
2970
+ (
2971
+ ((_la) & ~0x3F) == 0
2972
+ and (
2973
+ (1 << _la)
2974
+ & ((1 << Parser.PLUS) | (1 << Parser.MINUS) | (1 << Parser.NOT))
2975
+ )
2976
+ != 0
2977
+ )
2978
+ ):
2486
2979
  localctx.op = self._errHandler.recoverInline(self)
2487
2980
  else:
2488
2981
  self._errHandler.reportMatch(self)
@@ -2538,15 +3031,15 @@ class Parser(Parser):
2538
3031
  self._errHandler.sync(self)
2539
3032
  la_ = self._interp.adaptivePredict(self._input, 8, self._ctx)
2540
3033
  if la_ == 1:
2541
- localctx = Parser.ArithmeticExprCompContext(self,
2542
- Parser.ExprComponentContext(
2543
- self, _parentctx,
2544
- _parentState))
3034
+ localctx = Parser.ArithmeticExprCompContext(
3035
+ self, Parser.ExprComponentContext(self, _parentctx, _parentState)
3036
+ )
2545
3037
  localctx.left = _prevctx
2546
3038
  self.pushNewRecursionContext(localctx, _startState, self.RULE_exprComponent)
2547
3039
  self.state = 312
2548
3040
  if not self.precpred(self._ctx, 9):
2549
3041
  from antlr4.error.Errors import FailedPredicateException
3042
+
2550
3043
  raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
2551
3044
  self.state = 313
2552
3045
  localctx.op = self._input.LT(1)
@@ -2561,15 +3054,15 @@ class Parser(Parser):
2561
3054
  pass
2562
3055
 
2563
3056
  elif la_ == 2:
2564
- localctx = Parser.ArithmeticExprOrConcatCompContext(self,
2565
- Parser.ExprComponentContext(
2566
- self, _parentctx,
2567
- _parentState))
3057
+ localctx = Parser.ArithmeticExprOrConcatCompContext(
3058
+ self, Parser.ExprComponentContext(self, _parentctx, _parentState)
3059
+ )
2568
3060
  localctx.left = _prevctx
2569
3061
  self.pushNewRecursionContext(localctx, _startState, self.RULE_exprComponent)
2570
3062
  self.state = 315
2571
3063
  if not self.precpred(self._ctx, 8):
2572
3064
  from antlr4.error.Errors import FailedPredicateException
3065
+
2573
3066
  raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
2574
3067
  self.state = 316
2575
3068
  localctx.op = self._input.LT(1)
@@ -2584,15 +3077,15 @@ class Parser(Parser):
2584
3077
  pass
2585
3078
 
2586
3079
  elif la_ == 3:
2587
- localctx = Parser.ComparisonExprCompContext(self,
2588
- Parser.ExprComponentContext(
2589
- self, _parentctx,
2590
- _parentState))
3080
+ localctx = Parser.ComparisonExprCompContext(
3081
+ self, Parser.ExprComponentContext(self, _parentctx, _parentState)
3082
+ )
2591
3083
  localctx.left = _prevctx
2592
3084
  self.pushNewRecursionContext(localctx, _startState, self.RULE_exprComponent)
2593
3085
  self.state = 318
2594
3086
  if not self.precpred(self._ctx, 7):
2595
3087
  from antlr4.error.Errors import FailedPredicateException
3088
+
2596
3089
  raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
2597
3090
  self.state = 319
2598
3091
  self.comparisonOperand()
@@ -2601,15 +3094,15 @@ class Parser(Parser):
2601
3094
  pass
2602
3095
 
2603
3096
  elif la_ == 4:
2604
- localctx = Parser.BooleanExprCompContext(self,
2605
- Parser.ExprComponentContext(self,
2606
- _parentctx,
2607
- _parentState))
3097
+ localctx = Parser.BooleanExprCompContext(
3098
+ self, Parser.ExprComponentContext(self, _parentctx, _parentState)
3099
+ )
2608
3100
  localctx.left = _prevctx
2609
3101
  self.pushNewRecursionContext(localctx, _startState, self.RULE_exprComponent)
2610
3102
  self.state = 322
2611
3103
  if not self.precpred(self._ctx, 5):
2612
3104
  from antlr4.error.Errors import FailedPredicateException
3105
+
2613
3106
  raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
2614
3107
  self.state = 323
2615
3108
  localctx.op = self.match(Parser.AND)
@@ -2618,15 +3111,15 @@ class Parser(Parser):
2618
3111
  pass
2619
3112
 
2620
3113
  elif la_ == 5:
2621
- localctx = Parser.BooleanExprCompContext(self,
2622
- Parser.ExprComponentContext(self,
2623
- _parentctx,
2624
- _parentState))
3114
+ localctx = Parser.BooleanExprCompContext(
3115
+ self, Parser.ExprComponentContext(self, _parentctx, _parentState)
3116
+ )
2625
3117
  localctx.left = _prevctx
2626
3118
  self.pushNewRecursionContext(localctx, _startState, self.RULE_exprComponent)
2627
3119
  self.state = 325
2628
3120
  if not self.precpred(self._ctx, 4):
2629
3121
  from antlr4.error.Errors import FailedPredicateException
3122
+
2630
3123
  raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
2631
3124
  self.state = 326
2632
3125
  localctx.op = self._input.LT(1)
@@ -2641,15 +3134,15 @@ class Parser(Parser):
2641
3134
  pass
2642
3135
 
2643
3136
  elif la_ == 6:
2644
- localctx = Parser.InNotInExprCompContext(self,
2645
- Parser.ExprComponentContext(self,
2646
- _parentctx,
2647
- _parentState))
3137
+ localctx = Parser.InNotInExprCompContext(
3138
+ self, Parser.ExprComponentContext(self, _parentctx, _parentState)
3139
+ )
2648
3140
  localctx.left = _prevctx
2649
3141
  self.pushNewRecursionContext(localctx, _startState, self.RULE_exprComponent)
2650
3142
  self.state = 328
2651
3143
  if not self.precpred(self._ctx, 6):
2652
3144
  from antlr4.error.Errors import FailedPredicateException
3145
+
2653
3146
  raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
2654
3147
  self.state = 329
2655
3148
  localctx.op = self._input.LT(1)
@@ -2701,8 +3194,9 @@ class Parser(Parser):
2701
3194
 
2702
3195
  class NumericFunctionsComponentsContext(FunctionsComponentsContext):
2703
3196
 
2704
- def __init__(self, parser,
2705
- ctx: ParserRuleContext): # actually a VtlParser.FunctionsComponentsContext
3197
+ def __init__(
3198
+ self, parser, ctx: ParserRuleContext
3199
+ ): # actually a VtlParser.FunctionsComponentsContext
2706
3200
  super().__init__(parser)
2707
3201
  self.copyFrom(ctx)
2708
3202
 
@@ -2717,8 +3211,9 @@ class Parser(Parser):
2717
3211
 
2718
3212
  class StringFunctionsComponentsContext(FunctionsComponentsContext):
2719
3213
 
2720
- def __init__(self, parser,
2721
- ctx: ParserRuleContext): # actually a VtlParser.FunctionsComponentsContext
3214
+ def __init__(
3215
+ self, parser, ctx: ParserRuleContext
3216
+ ): # actually a VtlParser.FunctionsComponentsContext
2722
3217
  super().__init__(parser)
2723
3218
  self.copyFrom(ctx)
2724
3219
 
@@ -2733,8 +3228,9 @@ class Parser(Parser):
2733
3228
 
2734
3229
  class ComparisonFunctionsComponentsContext(FunctionsComponentsContext):
2735
3230
 
2736
- def __init__(self, parser,
2737
- ctx: ParserRuleContext): # actually a VtlParser.FunctionsComponentsContext
3231
+ def __init__(
3232
+ self, parser, ctx: ParserRuleContext
3233
+ ): # actually a VtlParser.FunctionsComponentsContext
2738
3234
  super().__init__(parser)
2739
3235
  self.copyFrom(ctx)
2740
3236
 
@@ -2749,8 +3245,9 @@ class Parser(Parser):
2749
3245
 
2750
3246
  class TimeFunctionsComponentsContext(FunctionsComponentsContext):
2751
3247
 
2752
- def __init__(self, parser,
2753
- ctx: ParserRuleContext): # actually a VtlParser.FunctionsComponentsContext
3248
+ def __init__(
3249
+ self, parser, ctx: ParserRuleContext
3250
+ ): # actually a VtlParser.FunctionsComponentsContext
2754
3251
  super().__init__(parser)
2755
3252
  self.copyFrom(ctx)
2756
3253
 
@@ -2765,8 +3262,9 @@ class Parser(Parser):
2765
3262
 
2766
3263
  class GenericFunctionsComponentsContext(FunctionsComponentsContext):
2767
3264
 
2768
- def __init__(self, parser,
2769
- ctx: ParserRuleContext): # actually a VtlParser.FunctionsComponentsContext
3265
+ def __init__(
3266
+ self, parser, ctx: ParserRuleContext
3267
+ ): # actually a VtlParser.FunctionsComponentsContext
2770
3268
  super().__init__(parser)
2771
3269
  self.copyFrom(ctx)
2772
3270
 
@@ -2781,8 +3279,9 @@ class Parser(Parser):
2781
3279
 
2782
3280
  class AnalyticFunctionsComponentsContext(FunctionsComponentsContext):
2783
3281
 
2784
- def __init__(self, parser,
2785
- ctx: ParserRuleContext): # actually a VtlParser.FunctionsComponentsContext
3282
+ def __init__(
3283
+ self, parser, ctx: ParserRuleContext
3284
+ ): # actually a VtlParser.FunctionsComponentsContext
2786
3285
  super().__init__(parser)
2787
3286
  self.copyFrom(ctx)
2788
3287
 
@@ -2797,8 +3296,9 @@ class Parser(Parser):
2797
3296
 
2798
3297
  class ConditionalFunctionsComponentsContext(FunctionsComponentsContext):
2799
3298
 
2800
- def __init__(self, parser,
2801
- ctx: ParserRuleContext): # actually a VtlParser.FunctionsComponentsContext
3299
+ def __init__(
3300
+ self, parser, ctx: ParserRuleContext
3301
+ ): # actually a VtlParser.FunctionsComponentsContext
2802
3302
  super().__init__(parser)
2803
3303
  self.copyFrom(ctx)
2804
3304
 
@@ -2813,8 +3313,9 @@ class Parser(Parser):
2813
3313
 
2814
3314
  class AggregateFunctionsComponentsContext(FunctionsComponentsContext):
2815
3315
 
2816
- def __init__(self, parser,
2817
- ctx: ParserRuleContext): # actually a VtlParser.FunctionsComponentsContext
3316
+ def __init__(
3317
+ self, parser, ctx: ParserRuleContext
3318
+ ): # actually a VtlParser.FunctionsComponentsContext
2818
3319
  super().__init__(parser)
2819
3320
  self.copyFrom(ctx)
2820
3321
 
@@ -2891,7 +3392,6 @@ class Parser(Parser):
2891
3392
  self.anFunctionComponent()
2892
3393
  pass
2893
3394
 
2894
-
2895
3395
  except RecognitionException as re:
2896
3396
  localctx.exception = re
2897
3397
  self._errHandler.reportError(self, re)
@@ -3184,7 +3684,6 @@ class Parser(Parser):
3184
3684
  self.anFunction()
3185
3685
  pass
3186
3686
 
3187
-
3188
3687
  except RecognitionException as re:
3189
3688
  localctx.exception = re
3190
3689
  self._errHandler.reportError(self, re)
@@ -3395,9 +3894,6 @@ class Parser(Parser):
3395
3894
  self.state = 384
3396
3895
  self.havingClause()
3397
3896
 
3398
-
3399
-
3400
-
3401
3897
  except RecognitionException as re:
3402
3898
  localctx.exception = re
3403
3899
  self._errHandler.reportError(self, re)
@@ -3714,8 +4210,9 @@ class Parser(Parser):
3714
4210
 
3715
4211
  class JoinExprContext(JoinOperatorsContext):
3716
4212
 
3717
- def __init__(self, parser,
3718
- ctx: ParserRuleContext): # actually a VtlParser.JoinOperatorsContext
4213
+ def __init__(
4214
+ self, parser, ctx: ParserRuleContext
4215
+ ): # actually a VtlParser.JoinOperatorsContext
3719
4216
  super().__init__(parser)
3720
4217
  self.joinKeyword = None # Token
3721
4218
  self.copyFrom(ctx)
@@ -3827,8 +4324,9 @@ class Parser(Parser):
3827
4324
 
3828
4325
  class DefOperatorContext(DefOperatorsContext):
3829
4326
 
3830
- def __init__(self, parser,
3831
- ctx: ParserRuleContext): # actually a VtlParser.DefOperatorsContext
4327
+ def __init__(
4328
+ self, parser, ctx: ParserRuleContext
4329
+ ): # actually a VtlParser.DefOperatorsContext
3832
4330
  super().__init__(parser)
3833
4331
  self.copyFrom(ctx)
3834
4332
 
@@ -3885,8 +4383,9 @@ class Parser(Parser):
3885
4383
 
3886
4384
  class DefHierarchicalContext(DefOperatorsContext):
3887
4385
 
3888
- def __init__(self, parser,
3889
- ctx: ParserRuleContext): # actually a VtlParser.DefOperatorsContext
4386
+ def __init__(
4387
+ self, parser, ctx: ParserRuleContext
4388
+ ): # actually a VtlParser.DefOperatorsContext
3890
4389
  super().__init__(parser)
3891
4390
  self.copyFrom(ctx)
3892
4391
 
@@ -3934,8 +4433,9 @@ class Parser(Parser):
3934
4433
 
3935
4434
  class DefDatapointRulesetContext(DefOperatorsContext):
3936
4435
 
3937
- def __init__(self, parser,
3938
- ctx: ParserRuleContext): # actually a VtlParser.DefOperatorsContext
4436
+ def __init__(
4437
+ self, parser, ctx: ParserRuleContext
4438
+ ): # actually a VtlParser.DefOperatorsContext
3939
4439
  super().__init__(parser)
3940
4440
  self.copyFrom(ctx)
3941
4441
 
@@ -4099,7 +4599,6 @@ class Parser(Parser):
4099
4599
  self.match(Parser.RULESET)
4100
4600
  pass
4101
4601
 
4102
-
4103
4602
  except RecognitionException as re:
4104
4603
  localctx.exception = re
4105
4604
  self._errHandler.reportError(self, re)
@@ -4122,8 +4621,9 @@ class Parser(Parser):
4122
4621
 
4123
4622
  class EvalAtomContext(GenericOperatorsContext):
4124
4623
 
4125
- def __init__(self, parser,
4126
- ctx: ParserRuleContext): # actually a VtlParser.GenericOperatorsContext
4624
+ def __init__(
4625
+ self, parser, ctx: ParserRuleContext
4626
+ ): # actually a VtlParser.GenericOperatorsContext
4127
4627
  super().__init__(parser)
4128
4628
  self.copyFrom(ctx)
4129
4629
 
@@ -4183,8 +4683,9 @@ class Parser(Parser):
4183
4683
 
4184
4684
  class CastExprDatasetContext(GenericOperatorsContext):
4185
4685
 
4186
- def __init__(self, parser,
4187
- ctx: ParserRuleContext): # actually a VtlParser.GenericOperatorsContext
4686
+ def __init__(
4687
+ self, parser, ctx: ParserRuleContext
4688
+ ): # actually a VtlParser.GenericOperatorsContext
4188
4689
  super().__init__(parser)
4189
4690
  self.copyFrom(ctx)
4190
4691
 
@@ -4223,8 +4724,9 @@ class Parser(Parser):
4223
4724
 
4224
4725
  class CallDatasetContext(GenericOperatorsContext):
4225
4726
 
4226
- def __init__(self, parser,
4227
- ctx: ParserRuleContext): # actually a VtlParser.GenericOperatorsContext
4727
+ def __init__(
4728
+ self, parser, ctx: ParserRuleContext
4729
+ ): # actually a VtlParser.GenericOperatorsContext
4228
4730
  super().__init__(parser)
4229
4731
  self.copyFrom(ctx)
4230
4732
 
@@ -4274,69 +4776,117 @@ class Parser(Parser):
4274
4776
  self.state = 500
4275
4777
  self._errHandler.sync(self)
4276
4778
  _la = self._input.LA(1)
4277
- if (((_la) & ~0x3f) == 0 and ((1 << _la) & (
4278
- (1 << Parser.LPAREN) | (1 << Parser.PLUS) | (1 << Parser.MINUS) | (
4279
- 1 << Parser.EVAL) | (1 << Parser.IF) | (1 << Parser.CURRENT_DATE) | (
4280
- 1 << Parser.NOT) | (1 << Parser.BETWEEN) | (
4281
- 1 << Parser.NULL_CONSTANT) | (1 << Parser.ISNULL) | (
4282
- 1 << Parser.UNION) | (1 << Parser.SYMDIFF) | (
4283
- 1 << Parser.INTERSECT) | (1 << Parser.CHECK) | (
4284
- 1 << Parser.EXISTS_IN))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and (
4285
- (1 << (_la - 68)) & ((1 << (Parser.MIN - 68)) | (1 << (Parser.MAX - 68)) | (
4286
- 1 << (Parser.ABS - 68)) | (1 << (Parser.LN - 68)) | (
4287
- 1 << (Parser.LOG - 68)) | (
4288
- 1 << (Parser.TRUNC - 68)) | (
4289
- 1 << (Parser.ROUND - 68)) | (
4290
- 1 << (Parser.POWER - 68)) | (
4291
- 1 << (Parser.MOD - 68)) | (
4292
- 1 << (Parser.LEN - 68)) | (
4293
- 1 << (Parser.TRIM - 68)) | (
4294
- 1 << (Parser.UCASE - 68)) | (
4295
- 1 << (Parser.LCASE - 68)) | (
4296
- 1 << (Parser.SUBSTR - 68)) | (
4297
- 1 << (Parser.SUM - 68)) | (
4298
- 1 << (Parser.AVG - 68)) | (
4299
- 1 << (Parser.MEDIAN - 68)) | (
4300
- 1 << (Parser.COUNT - 68)) | (
4301
- 1 << (Parser.EXP - 68)) | (
4302
- 1 << (Parser.CHARSET_MATCH - 68)) | (
4303
- 1 << (Parser.NVL - 68)) | (
4304
- 1 << (Parser.HIERARCHY - 68)) | (
4305
- 1 << (Parser.OPTIONAL - 68)) | (
4306
- 1 << (Parser.LTRIM - 68)) | (
4307
- 1 << (Parser.RTRIM - 68)) | (
4308
- 1 << (Parser.INSTR - 68)) | (
4309
- 1 << (Parser.REPLACE - 68)) | (
4310
- 1 << (Parser.CEIL - 68)) | (
4311
- 1 << (Parser.FLOOR - 68)) | (
4312
- 1 << (Parser.SQRT - 68)) | (
4313
- 1 << (Parser.SETDIFF - 68)) | (
4314
- 1 << (Parser.STDDEV_POP - 68)) | (
4315
- 1 << (Parser.STDDEV_SAMP - 68)) | (
4316
- 1 << (Parser.VAR_POP - 68)) | (
4317
- 1 << (Parser.VAR_SAMP - 68)))) != 0) or (
4318
- (((_la - 135)) & ~0x3f) == 0 and ((1 << (_la - 135)) & (
4319
- (1 << (Parser.FIRST_VALUE - 135)) | (1 << (Parser.LAST_VALUE - 135)) | (
4320
- 1 << (Parser.LAG - 135)) | (1 << (Parser.LEAD - 135)) | (
4321
- 1 << (Parser.RATIO_TO_REPORT - 135)) | (
4322
- 1 << (Parser.FILL_TIME_SERIES - 135)) | (
4323
- 1 << (Parser.FLOW_TO_STOCK - 135)) | (
4324
- 1 << (Parser.STOCK_TO_FLOW - 135)) | (
4325
- 1 << (Parser.TIMESHIFT - 135)) | (
4326
- 1 << (Parser.INNER_JOIN - 135)) | (
4327
- 1 << (Parser.LEFT_JOIN - 135)) | (
4328
- 1 << (Parser.CROSS_JOIN - 135)) | (
4329
- 1 << (Parser.FULL_JOIN - 135)) | (
4330
- 1 << (Parser.PERIOD_INDICATOR - 135)))) != 0) or (
4331
- (((_la - 199)) & ~0x3f) == 0 and ((1 << (_la - 199)) & (
4332
- (1 << (Parser.TIME_AGG - 199)) | (1 << (Parser.CAST - 199)) | (
4333
- 1 << (Parser.CHECK_DATAPOINT - 199)) | (
4334
- 1 << (Parser.CHECK_HIERARCHY - 199)) | (
4335
- 1 << (Parser.INTEGER_CONSTANT - 199)) | (
4336
- 1 << (Parser.NUMBER_CONSTANT - 199)) | (
4337
- 1 << (Parser.BOOLEAN_CONSTANT - 199)) | (
4338
- 1 << (Parser.STRING_CONSTANT - 199)) | (
4339
- 1 << (Parser.IDENTIFIER - 199)))) != 0):
4779
+ if (
4780
+ (
4781
+ ((_la) & ~0x3F) == 0
4782
+ and (
4783
+ (1 << _la)
4784
+ & (
4785
+ (1 << Parser.LPAREN)
4786
+ | (1 << Parser.PLUS)
4787
+ | (1 << Parser.MINUS)
4788
+ | (1 << Parser.EVAL)
4789
+ | (1 << Parser.IF)
4790
+ | (1 << Parser.CURRENT_DATE)
4791
+ | (1 << Parser.NOT)
4792
+ | (1 << Parser.BETWEEN)
4793
+ | (1 << Parser.NULL_CONSTANT)
4794
+ | (1 << Parser.ISNULL)
4795
+ | (1 << Parser.UNION)
4796
+ | (1 << Parser.SYMDIFF)
4797
+ | (1 << Parser.INTERSECT)
4798
+ | (1 << Parser.CHECK)
4799
+ | (1 << Parser.EXISTS_IN)
4800
+ )
4801
+ )
4802
+ != 0
4803
+ )
4804
+ or (
4805
+ (((_la - 68)) & ~0x3F) == 0
4806
+ and (
4807
+ (1 << (_la - 68))
4808
+ & (
4809
+ (1 << (Parser.MIN - 68))
4810
+ | (1 << (Parser.MAX - 68))
4811
+ | (1 << (Parser.ABS - 68))
4812
+ | (1 << (Parser.LN - 68))
4813
+ | (1 << (Parser.LOG - 68))
4814
+ | (1 << (Parser.TRUNC - 68))
4815
+ | (1 << (Parser.ROUND - 68))
4816
+ | (1 << (Parser.POWER - 68))
4817
+ | (1 << (Parser.MOD - 68))
4818
+ | (1 << (Parser.LEN - 68))
4819
+ | (1 << (Parser.TRIM - 68))
4820
+ | (1 << (Parser.UCASE - 68))
4821
+ | (1 << (Parser.LCASE - 68))
4822
+ | (1 << (Parser.SUBSTR - 68))
4823
+ | (1 << (Parser.SUM - 68))
4824
+ | (1 << (Parser.AVG - 68))
4825
+ | (1 << (Parser.MEDIAN - 68))
4826
+ | (1 << (Parser.COUNT - 68))
4827
+ | (1 << (Parser.EXP - 68))
4828
+ | (1 << (Parser.CHARSET_MATCH - 68))
4829
+ | (1 << (Parser.NVL - 68))
4830
+ | (1 << (Parser.HIERARCHY - 68))
4831
+ | (1 << (Parser.OPTIONAL - 68))
4832
+ | (1 << (Parser.LTRIM - 68))
4833
+ | (1 << (Parser.RTRIM - 68))
4834
+ | (1 << (Parser.INSTR - 68))
4835
+ | (1 << (Parser.REPLACE - 68))
4836
+ | (1 << (Parser.CEIL - 68))
4837
+ | (1 << (Parser.FLOOR - 68))
4838
+ | (1 << (Parser.SQRT - 68))
4839
+ | (1 << (Parser.SETDIFF - 68))
4840
+ | (1 << (Parser.STDDEV_POP - 68))
4841
+ | (1 << (Parser.STDDEV_SAMP - 68))
4842
+ | (1 << (Parser.VAR_POP - 68))
4843
+ | (1 << (Parser.VAR_SAMP - 68))
4844
+ )
4845
+ )
4846
+ != 0
4847
+ )
4848
+ or (
4849
+ (((_la - 135)) & ~0x3F) == 0
4850
+ and (
4851
+ (1 << (_la - 135))
4852
+ & (
4853
+ (1 << (Parser.FIRST_VALUE - 135))
4854
+ | (1 << (Parser.LAST_VALUE - 135))
4855
+ | (1 << (Parser.LAG - 135))
4856
+ | (1 << (Parser.LEAD - 135))
4857
+ | (1 << (Parser.RATIO_TO_REPORT - 135))
4858
+ | (1 << (Parser.FILL_TIME_SERIES - 135))
4859
+ | (1 << (Parser.FLOW_TO_STOCK - 135))
4860
+ | (1 << (Parser.STOCK_TO_FLOW - 135))
4861
+ | (1 << (Parser.TIMESHIFT - 135))
4862
+ | (1 << (Parser.INNER_JOIN - 135))
4863
+ | (1 << (Parser.LEFT_JOIN - 135))
4864
+ | (1 << (Parser.CROSS_JOIN - 135))
4865
+ | (1 << (Parser.FULL_JOIN - 135))
4866
+ | (1 << (Parser.PERIOD_INDICATOR - 135))
4867
+ )
4868
+ )
4869
+ != 0
4870
+ )
4871
+ or (
4872
+ (((_la - 199)) & ~0x3F) == 0
4873
+ and (
4874
+ (1 << (_la - 199))
4875
+ & (
4876
+ (1 << (Parser.TIME_AGG - 199))
4877
+ | (1 << (Parser.CAST - 199))
4878
+ | (1 << (Parser.CHECK_DATAPOINT - 199))
4879
+ | (1 << (Parser.CHECK_HIERARCHY - 199))
4880
+ | (1 << (Parser.INTEGER_CONSTANT - 199))
4881
+ | (1 << (Parser.NUMBER_CONSTANT - 199))
4882
+ | (1 << (Parser.BOOLEAN_CONSTANT - 199))
4883
+ | (1 << (Parser.STRING_CONSTANT - 199))
4884
+ | (1 << (Parser.IDENTIFIER - 199))
4885
+ )
4886
+ )
4887
+ != 0
4888
+ )
4889
+ ):
4340
4890
  self.state = 492
4341
4891
  self.parameter()
4342
4892
  self.state = 497
@@ -4372,9 +4922,14 @@ class Parser(Parser):
4372
4922
  self.state = 508
4373
4923
  self.varID()
4374
4924
  pass
4375
- elif token in [Parser.NULL_CONSTANT, Parser.CAST, Parser.INTEGER_CONSTANT,
4376
- Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT,
4377
- Parser.STRING_CONSTANT]:
4925
+ elif token in [
4926
+ Parser.NULL_CONSTANT,
4927
+ Parser.CAST,
4928
+ Parser.INTEGER_CONSTANT,
4929
+ Parser.NUMBER_CONSTANT,
4930
+ Parser.BOOLEAN_CONSTANT,
4931
+ Parser.STRING_CONSTANT,
4932
+ ]:
4378
4933
  self.state = 509
4379
4934
  self.scalarItem()
4380
4935
  pass
@@ -4395,9 +4950,14 @@ class Parser(Parser):
4395
4950
  self.state = 513
4396
4951
  self.varID()
4397
4952
  pass
4398
- elif token in [Parser.NULL_CONSTANT, Parser.CAST, Parser.INTEGER_CONSTANT,
4399
- Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT,
4400
- Parser.STRING_CONSTANT]:
4953
+ elif token in [
4954
+ Parser.NULL_CONSTANT,
4955
+ Parser.CAST,
4956
+ Parser.INTEGER_CONSTANT,
4957
+ Parser.NUMBER_CONSTANT,
4958
+ Parser.BOOLEAN_CONSTANT,
4959
+ Parser.STRING_CONSTANT,
4960
+ ]:
4401
4961
  self.state = 514
4402
4962
  self.scalarItem()
4403
4963
  pass
@@ -4445,9 +5005,17 @@ class Parser(Parser):
4445
5005
  self.state = 539
4446
5006
  self._errHandler.sync(self)
4447
5007
  token = self._input.LA(1)
4448
- if token in [Parser.BOOLEAN, Parser.DATE, Parser.TIME_PERIOD, Parser.NUMBER,
4449
- Parser.STRING, Parser.TIME, Parser.INTEGER, Parser.DURATION,
4450
- Parser.SCALAR]:
5008
+ if token in [
5009
+ Parser.BOOLEAN,
5010
+ Parser.DATE,
5011
+ Parser.TIME_PERIOD,
5012
+ Parser.NUMBER,
5013
+ Parser.STRING,
5014
+ Parser.TIME,
5015
+ Parser.INTEGER,
5016
+ Parser.DURATION,
5017
+ Parser.SCALAR,
5018
+ ]:
4451
5019
  self.state = 537
4452
5020
  self.basicScalarType()
4453
5021
  pass
@@ -4495,8 +5063,9 @@ class Parser(Parser):
4495
5063
 
4496
5064
  class EvalAtomComponentContext(GenericOperatorsComponentContext):
4497
5065
 
4498
- def __init__(self, parser,
4499
- ctx: ParserRuleContext): # actually a VtlParser.GenericOperatorsComponentContext
5066
+ def __init__(
5067
+ self, parser, ctx: ParserRuleContext
5068
+ ): # actually a VtlParser.GenericOperatorsComponentContext
4500
5069
  super().__init__(parser)
4501
5070
  self.copyFrom(ctx)
4502
5071
 
@@ -4556,8 +5125,9 @@ class Parser(Parser):
4556
5125
 
4557
5126
  class CastExprComponentContext(GenericOperatorsComponentContext):
4558
5127
 
4559
- def __init__(self, parser,
4560
- ctx: ParserRuleContext): # actually a VtlParser.GenericOperatorsComponentContext
5128
+ def __init__(
5129
+ self, parser, ctx: ParserRuleContext
5130
+ ): # actually a VtlParser.GenericOperatorsComponentContext
4561
5131
  super().__init__(parser)
4562
5132
  self.copyFrom(ctx)
4563
5133
 
@@ -4596,8 +5166,9 @@ class Parser(Parser):
4596
5166
 
4597
5167
  class CallComponentContext(GenericOperatorsComponentContext):
4598
5168
 
4599
- def __init__(self, parser,
4600
- ctx: ParserRuleContext): # actually a VtlParser.GenericOperatorsComponentContext
5169
+ def __init__(
5170
+ self, parser, ctx: ParserRuleContext
5171
+ ): # actually a VtlParser.GenericOperatorsComponentContext
4601
5172
  super().__init__(parser)
4602
5173
  self.copyFrom(ctx)
4603
5174
 
@@ -4647,45 +5218,105 @@ class Parser(Parser):
4647
5218
  self.state = 559
4648
5219
  self._errHandler.sync(self)
4649
5220
  _la = self._input.LA(1)
4650
- if (((_la) & ~0x3f) == 0 and ((1 << _la) & (
4651
- (1 << Parser.LPAREN) | (1 << Parser.PLUS) | (1 << Parser.MINUS) | (
4652
- 1 << Parser.EVAL) | (1 << Parser.IF) | (1 << Parser.CURRENT_DATE) | (
4653
- 1 << Parser.NOT) | (1 << Parser.BETWEEN) | (
4654
- 1 << Parser.NULL_CONSTANT) | (1 << Parser.ISNULL))) != 0) or (
4655
- (((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & (
4656
- (1 << (Parser.RANK - 65)) | (1 << (Parser.MIN - 65)) | (
4657
- 1 << (Parser.MAX - 65)) | (1 << (Parser.ABS - 65)) | (
4658
- 1 << (Parser.LN - 65)) | (1 << (Parser.LOG - 65)) | (
4659
- 1 << (Parser.TRUNC - 65)) | (1 << (Parser.ROUND - 65)) | (
4660
- 1 << (Parser.POWER - 65)) | (1 << (Parser.MOD - 65)) | (
4661
- 1 << (Parser.LEN - 65)) | (1 << (Parser.TRIM - 65)) | (
4662
- 1 << (Parser.UCASE - 65)) | (1 << (Parser.LCASE - 65)) | (
4663
- 1 << (Parser.SUBSTR - 65)) | (1 << (Parser.SUM - 65)) | (
4664
- 1 << (Parser.AVG - 65)) | (1 << (Parser.MEDIAN - 65)) | (
4665
- 1 << (Parser.COUNT - 65)) | (1 << (Parser.EXP - 65)) | (
4666
- 1 << (Parser.CHARSET_MATCH - 65)) | (1 << (Parser.NVL - 65)) | (
4667
- 1 << (Parser.OPTIONAL - 65)) | (1 << (Parser.LTRIM - 65)) | (
4668
- 1 << (Parser.RTRIM - 65)) | (1 << (Parser.INSTR - 65)) | (
4669
- 1 << (Parser.REPLACE - 65)) | (1 << (Parser.CEIL - 65)) | (
4670
- 1 << (Parser.FLOOR - 65)) | (1 << (Parser.SQRT - 65)) | (
4671
- 1 << (Parser.STDDEV_POP - 65)))) != 0) or (
4672
- (((_la - 129)) & ~0x3f) == 0 and ((1 << (_la - 129)) & (
4673
- (1 << (Parser.STDDEV_SAMP - 129)) | (1 << (Parser.VAR_POP - 129)) | (
4674
- 1 << (Parser.VAR_SAMP - 129)) | (1 << (Parser.FIRST_VALUE - 129)) | (
4675
- 1 << (Parser.LAST_VALUE - 129)) | (1 << (Parser.LAG - 129)) | (
4676
- 1 << (Parser.LEAD - 129)) | (
4677
- 1 << (Parser.RATIO_TO_REPORT - 129)) | (
4678
- 1 << (Parser.FILL_TIME_SERIES - 129)) | (
4679
- 1 << (Parser.FLOW_TO_STOCK - 129)) | (
4680
- 1 << (Parser.STOCK_TO_FLOW - 129)) | (
4681
- 1 << (Parser.TIMESHIFT - 129)))) != 0) or (
4682
- (((_la - 196)) & ~0x3f) == 0 and ((1 << (_la - 196)) & (
4683
- (1 << (Parser.PERIOD_INDICATOR - 196)) | (1 << (Parser.TIME_AGG - 196)) | (
4684
- 1 << (Parser.CAST - 196)) | (1 << (Parser.INTEGER_CONSTANT - 196)) | (
4685
- 1 << (Parser.NUMBER_CONSTANT - 196)) | (
4686
- 1 << (Parser.BOOLEAN_CONSTANT - 196)) | (
4687
- 1 << (Parser.STRING_CONSTANT - 196)) | (
4688
- 1 << (Parser.IDENTIFIER - 196)))) != 0):
5221
+ if (
5222
+ (
5223
+ ((_la) & ~0x3F) == 0
5224
+ and (
5225
+ (1 << _la)
5226
+ & (
5227
+ (1 << Parser.LPAREN)
5228
+ | (1 << Parser.PLUS)
5229
+ | (1 << Parser.MINUS)
5230
+ | (1 << Parser.EVAL)
5231
+ | (1 << Parser.IF)
5232
+ | (1 << Parser.CURRENT_DATE)
5233
+ | (1 << Parser.NOT)
5234
+ | (1 << Parser.BETWEEN)
5235
+ | (1 << Parser.NULL_CONSTANT)
5236
+ | (1 << Parser.ISNULL)
5237
+ )
5238
+ )
5239
+ != 0
5240
+ )
5241
+ or (
5242
+ (((_la - 65)) & ~0x3F) == 0
5243
+ and (
5244
+ (1 << (_la - 65))
5245
+ & (
5246
+ (1 << (Parser.RANK - 65))
5247
+ | (1 << (Parser.MIN - 65))
5248
+ | (1 << (Parser.MAX - 65))
5249
+ | (1 << (Parser.ABS - 65))
5250
+ | (1 << (Parser.LN - 65))
5251
+ | (1 << (Parser.LOG - 65))
5252
+ | (1 << (Parser.TRUNC - 65))
5253
+ | (1 << (Parser.ROUND - 65))
5254
+ | (1 << (Parser.POWER - 65))
5255
+ | (1 << (Parser.MOD - 65))
5256
+ | (1 << (Parser.LEN - 65))
5257
+ | (1 << (Parser.TRIM - 65))
5258
+ | (1 << (Parser.UCASE - 65))
5259
+ | (1 << (Parser.LCASE - 65))
5260
+ | (1 << (Parser.SUBSTR - 65))
5261
+ | (1 << (Parser.SUM - 65))
5262
+ | (1 << (Parser.AVG - 65))
5263
+ | (1 << (Parser.MEDIAN - 65))
5264
+ | (1 << (Parser.COUNT - 65))
5265
+ | (1 << (Parser.EXP - 65))
5266
+ | (1 << (Parser.CHARSET_MATCH - 65))
5267
+ | (1 << (Parser.NVL - 65))
5268
+ | (1 << (Parser.OPTIONAL - 65))
5269
+ | (1 << (Parser.LTRIM - 65))
5270
+ | (1 << (Parser.RTRIM - 65))
5271
+ | (1 << (Parser.INSTR - 65))
5272
+ | (1 << (Parser.REPLACE - 65))
5273
+ | (1 << (Parser.CEIL - 65))
5274
+ | (1 << (Parser.FLOOR - 65))
5275
+ | (1 << (Parser.SQRT - 65))
5276
+ | (1 << (Parser.STDDEV_POP - 65))
5277
+ )
5278
+ )
5279
+ != 0
5280
+ )
5281
+ or (
5282
+ (((_la - 129)) & ~0x3F) == 0
5283
+ and (
5284
+ (1 << (_la - 129))
5285
+ & (
5286
+ (1 << (Parser.STDDEV_SAMP - 129))
5287
+ | (1 << (Parser.VAR_POP - 129))
5288
+ | (1 << (Parser.VAR_SAMP - 129))
5289
+ | (1 << (Parser.FIRST_VALUE - 129))
5290
+ | (1 << (Parser.LAST_VALUE - 129))
5291
+ | (1 << (Parser.LAG - 129))
5292
+ | (1 << (Parser.LEAD - 129))
5293
+ | (1 << (Parser.RATIO_TO_REPORT - 129))
5294
+ | (1 << (Parser.FILL_TIME_SERIES - 129))
5295
+ | (1 << (Parser.FLOW_TO_STOCK - 129))
5296
+ | (1 << (Parser.STOCK_TO_FLOW - 129))
5297
+ | (1 << (Parser.TIMESHIFT - 129))
5298
+ )
5299
+ )
5300
+ != 0
5301
+ )
5302
+ or (
5303
+ (((_la - 196)) & ~0x3F) == 0
5304
+ and (
5305
+ (1 << (_la - 196))
5306
+ & (
5307
+ (1 << (Parser.PERIOD_INDICATOR - 196))
5308
+ | (1 << (Parser.TIME_AGG - 196))
5309
+ | (1 << (Parser.CAST - 196))
5310
+ | (1 << (Parser.INTEGER_CONSTANT - 196))
5311
+ | (1 << (Parser.NUMBER_CONSTANT - 196))
5312
+ | (1 << (Parser.BOOLEAN_CONSTANT - 196))
5313
+ | (1 << (Parser.STRING_CONSTANT - 196))
5314
+ | (1 << (Parser.IDENTIFIER - 196))
5315
+ )
5316
+ )
5317
+ != 0
5318
+ )
5319
+ ):
4689
5320
  self.state = 551
4690
5321
  self.parameterComponent()
4691
5322
  self.state = 556
@@ -4717,9 +5348,17 @@ class Parser(Parser):
4717
5348
  self.state = 569
4718
5349
  self._errHandler.sync(self)
4719
5350
  token = self._input.LA(1)
4720
- if token in [Parser.BOOLEAN, Parser.DATE, Parser.TIME_PERIOD, Parser.NUMBER,
4721
- Parser.STRING, Parser.TIME, Parser.INTEGER, Parser.DURATION,
4722
- Parser.SCALAR]:
5351
+ if token in [
5352
+ Parser.BOOLEAN,
5353
+ Parser.DATE,
5354
+ Parser.TIME_PERIOD,
5355
+ Parser.NUMBER,
5356
+ Parser.STRING,
5357
+ Parser.TIME,
5358
+ Parser.INTEGER,
5359
+ Parser.DURATION,
5360
+ Parser.SCALAR,
5361
+ ]:
4723
5362
  self.state = 567
4724
5363
  self.basicScalarType()
4725
5364
  pass
@@ -4760,9 +5399,14 @@ class Parser(Parser):
4760
5399
  self.state = 581
4761
5400
  self.componentID()
4762
5401
  pass
4763
- elif token in [Parser.NULL_CONSTANT, Parser.CAST, Parser.INTEGER_CONSTANT,
4764
- Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT,
4765
- Parser.STRING_CONSTANT]:
5402
+ elif token in [
5403
+ Parser.NULL_CONSTANT,
5404
+ Parser.CAST,
5405
+ Parser.INTEGER_CONSTANT,
5406
+ Parser.NUMBER_CONSTANT,
5407
+ Parser.BOOLEAN_CONSTANT,
5408
+ Parser.STRING_CONSTANT,
5409
+ ]:
4766
5410
  self.state = 582
4767
5411
  self.scalarItem()
4768
5412
  pass
@@ -4783,9 +5427,14 @@ class Parser(Parser):
4783
5427
  self.state = 586
4784
5428
  self.componentID()
4785
5429
  pass
4786
- elif token in [Parser.NULL_CONSTANT, Parser.CAST, Parser.INTEGER_CONSTANT,
4787
- Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT,
4788
- Parser.STRING_CONSTANT]:
5430
+ elif token in [
5431
+ Parser.NULL_CONSTANT,
5432
+ Parser.CAST,
5433
+ Parser.INTEGER_CONSTANT,
5434
+ Parser.NUMBER_CONSTANT,
5435
+ Parser.BOOLEAN_CONSTANT,
5436
+ Parser.STRING_CONSTANT,
5437
+ ]:
4789
5438
  self.state = 587
4790
5439
  self.scalarItem()
4791
5440
  pass
@@ -4859,20 +5508,68 @@ class Parser(Parser):
4859
5508
  self.state = 610
4860
5509
  self._errHandler.sync(self)
4861
5510
  token = self._input.LA(1)
4862
- if token in [Parser.LPAREN, Parser.PLUS, Parser.MINUS, Parser.EVAL, Parser.IF,
4863
- Parser.CURRENT_DATE, Parser.NOT, Parser.BETWEEN, Parser.NULL_CONSTANT,
4864
- Parser.ISNULL, Parser.RANK, Parser.MIN, Parser.MAX, Parser.ABS, Parser.LN,
4865
- Parser.LOG, Parser.TRUNC, Parser.ROUND, Parser.POWER, Parser.MOD,
4866
- Parser.LEN, Parser.TRIM, Parser.UCASE, Parser.LCASE, Parser.SUBSTR,
4867
- Parser.SUM, Parser.AVG, Parser.MEDIAN, Parser.COUNT, Parser.EXP,
4868
- Parser.CHARSET_MATCH, Parser.NVL, Parser.LTRIM, Parser.RTRIM, Parser.INSTR,
4869
- Parser.REPLACE, Parser.CEIL, Parser.FLOOR, Parser.SQRT, Parser.STDDEV_POP,
4870
- Parser.STDDEV_SAMP, Parser.VAR_POP, Parser.VAR_SAMP, Parser.FIRST_VALUE,
4871
- Parser.LAST_VALUE, Parser.LAG, Parser.LEAD, Parser.RATIO_TO_REPORT,
4872
- Parser.FILL_TIME_SERIES, Parser.FLOW_TO_STOCK, Parser.STOCK_TO_FLOW,
4873
- Parser.TIMESHIFT, Parser.PERIOD_INDICATOR, Parser.TIME_AGG, Parser.CAST,
4874
- Parser.INTEGER_CONSTANT, Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT,
4875
- Parser.STRING_CONSTANT, Parser.IDENTIFIER]:
5511
+ if token in [
5512
+ Parser.LPAREN,
5513
+ Parser.PLUS,
5514
+ Parser.MINUS,
5515
+ Parser.EVAL,
5516
+ Parser.IF,
5517
+ Parser.CURRENT_DATE,
5518
+ Parser.NOT,
5519
+ Parser.BETWEEN,
5520
+ Parser.NULL_CONSTANT,
5521
+ Parser.ISNULL,
5522
+ Parser.RANK,
5523
+ Parser.MIN,
5524
+ Parser.MAX,
5525
+ Parser.ABS,
5526
+ Parser.LN,
5527
+ Parser.LOG,
5528
+ Parser.TRUNC,
5529
+ Parser.ROUND,
5530
+ Parser.POWER,
5531
+ Parser.MOD,
5532
+ Parser.LEN,
5533
+ Parser.TRIM,
5534
+ Parser.UCASE,
5535
+ Parser.LCASE,
5536
+ Parser.SUBSTR,
5537
+ Parser.SUM,
5538
+ Parser.AVG,
5539
+ Parser.MEDIAN,
5540
+ Parser.COUNT,
5541
+ Parser.EXP,
5542
+ Parser.CHARSET_MATCH,
5543
+ Parser.NVL,
5544
+ Parser.LTRIM,
5545
+ Parser.RTRIM,
5546
+ Parser.INSTR,
5547
+ Parser.REPLACE,
5548
+ Parser.CEIL,
5549
+ Parser.FLOOR,
5550
+ Parser.SQRT,
5551
+ Parser.STDDEV_POP,
5552
+ Parser.STDDEV_SAMP,
5553
+ Parser.VAR_POP,
5554
+ Parser.VAR_SAMP,
5555
+ Parser.FIRST_VALUE,
5556
+ Parser.LAST_VALUE,
5557
+ Parser.LAG,
5558
+ Parser.LEAD,
5559
+ Parser.RATIO_TO_REPORT,
5560
+ Parser.FILL_TIME_SERIES,
5561
+ Parser.FLOW_TO_STOCK,
5562
+ Parser.STOCK_TO_FLOW,
5563
+ Parser.TIMESHIFT,
5564
+ Parser.PERIOD_INDICATOR,
5565
+ Parser.TIME_AGG,
5566
+ Parser.CAST,
5567
+ Parser.INTEGER_CONSTANT,
5568
+ Parser.NUMBER_CONSTANT,
5569
+ Parser.BOOLEAN_CONSTANT,
5570
+ Parser.STRING_CONSTANT,
5571
+ Parser.IDENTIFIER,
5572
+ ]:
4876
5573
  self.enterOuterAlt(localctx, 1)
4877
5574
  self.state = 608
4878
5575
  self.exprComponent(0)
@@ -4922,24 +5619,80 @@ class Parser(Parser):
4922
5619
  self.state = 614
4923
5620
  self._errHandler.sync(self)
4924
5621
  token = self._input.LA(1)
4925
- if token in [Parser.LPAREN, Parser.PLUS, Parser.MINUS, Parser.EVAL, Parser.IF,
4926
- Parser.CURRENT_DATE, Parser.NOT, Parser.BETWEEN, Parser.NULL_CONSTANT,
4927
- Parser.ISNULL, Parser.UNION, Parser.SYMDIFF, Parser.INTERSECT,
4928
- Parser.CHECK, Parser.EXISTS_IN, Parser.MIN, Parser.MAX, Parser.ABS,
4929
- Parser.LN, Parser.LOG, Parser.TRUNC, Parser.ROUND, Parser.POWER,
4930
- Parser.MOD, Parser.LEN, Parser.TRIM, Parser.UCASE, Parser.LCASE,
4931
- Parser.SUBSTR, Parser.SUM, Parser.AVG, Parser.MEDIAN, Parser.COUNT,
4932
- Parser.EXP, Parser.CHARSET_MATCH, Parser.NVL, Parser.HIERARCHY,
4933
- Parser.LTRIM, Parser.RTRIM, Parser.INSTR, Parser.REPLACE, Parser.CEIL,
4934
- Parser.FLOOR, Parser.SQRT, Parser.SETDIFF, Parser.STDDEV_POP,
4935
- Parser.STDDEV_SAMP, Parser.VAR_POP, Parser.VAR_SAMP, Parser.FIRST_VALUE,
4936
- Parser.LAST_VALUE, Parser.LAG, Parser.LEAD, Parser.RATIO_TO_REPORT,
4937
- Parser.FILL_TIME_SERIES, Parser.FLOW_TO_STOCK, Parser.STOCK_TO_FLOW,
4938
- Parser.TIMESHIFT, Parser.INNER_JOIN, Parser.LEFT_JOIN, Parser.CROSS_JOIN,
4939
- Parser.FULL_JOIN, Parser.PERIOD_INDICATOR, Parser.TIME_AGG, Parser.CAST,
4940
- Parser.CHECK_DATAPOINT, Parser.CHECK_HIERARCHY, Parser.INTEGER_CONSTANT,
4941
- Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT, Parser.STRING_CONSTANT,
4942
- Parser.IDENTIFIER]:
5622
+ if token in [
5623
+ Parser.LPAREN,
5624
+ Parser.PLUS,
5625
+ Parser.MINUS,
5626
+ Parser.EVAL,
5627
+ Parser.IF,
5628
+ Parser.CURRENT_DATE,
5629
+ Parser.NOT,
5630
+ Parser.BETWEEN,
5631
+ Parser.NULL_CONSTANT,
5632
+ Parser.ISNULL,
5633
+ Parser.UNION,
5634
+ Parser.SYMDIFF,
5635
+ Parser.INTERSECT,
5636
+ Parser.CHECK,
5637
+ Parser.EXISTS_IN,
5638
+ Parser.MIN,
5639
+ Parser.MAX,
5640
+ Parser.ABS,
5641
+ Parser.LN,
5642
+ Parser.LOG,
5643
+ Parser.TRUNC,
5644
+ Parser.ROUND,
5645
+ Parser.POWER,
5646
+ Parser.MOD,
5647
+ Parser.LEN,
5648
+ Parser.TRIM,
5649
+ Parser.UCASE,
5650
+ Parser.LCASE,
5651
+ Parser.SUBSTR,
5652
+ Parser.SUM,
5653
+ Parser.AVG,
5654
+ Parser.MEDIAN,
5655
+ Parser.COUNT,
5656
+ Parser.EXP,
5657
+ Parser.CHARSET_MATCH,
5658
+ Parser.NVL,
5659
+ Parser.HIERARCHY,
5660
+ Parser.LTRIM,
5661
+ Parser.RTRIM,
5662
+ Parser.INSTR,
5663
+ Parser.REPLACE,
5664
+ Parser.CEIL,
5665
+ Parser.FLOOR,
5666
+ Parser.SQRT,
5667
+ Parser.SETDIFF,
5668
+ Parser.STDDEV_POP,
5669
+ Parser.STDDEV_SAMP,
5670
+ Parser.VAR_POP,
5671
+ Parser.VAR_SAMP,
5672
+ Parser.FIRST_VALUE,
5673
+ Parser.LAST_VALUE,
5674
+ Parser.LAG,
5675
+ Parser.LEAD,
5676
+ Parser.RATIO_TO_REPORT,
5677
+ Parser.FILL_TIME_SERIES,
5678
+ Parser.FLOW_TO_STOCK,
5679
+ Parser.STOCK_TO_FLOW,
5680
+ Parser.TIMESHIFT,
5681
+ Parser.INNER_JOIN,
5682
+ Parser.LEFT_JOIN,
5683
+ Parser.CROSS_JOIN,
5684
+ Parser.FULL_JOIN,
5685
+ Parser.PERIOD_INDICATOR,
5686
+ Parser.TIME_AGG,
5687
+ Parser.CAST,
5688
+ Parser.CHECK_DATAPOINT,
5689
+ Parser.CHECK_HIERARCHY,
5690
+ Parser.INTEGER_CONSTANT,
5691
+ Parser.NUMBER_CONSTANT,
5692
+ Parser.BOOLEAN_CONSTANT,
5693
+ Parser.STRING_CONSTANT,
5694
+ Parser.IDENTIFIER,
5695
+ ]:
4943
5696
  self.enterOuterAlt(localctx, 1)
4944
5697
  self.state = 612
4945
5698
  self.expr(0)
@@ -4974,8 +5727,9 @@ class Parser(Parser):
4974
5727
 
4975
5728
  class InstrAtomContext(StringOperatorsContext):
4976
5729
 
4977
- def __init__(self, parser,
4978
- ctx: ParserRuleContext): # actually a VtlParser.StringOperatorsContext
5730
+ def __init__(
5731
+ self, parser, ctx: ParserRuleContext
5732
+ ): # actually a VtlParser.StringOperatorsContext
4979
5733
  super().__init__(parser)
4980
5734
  self.pattern = None # ExprContext
4981
5735
  self.startParameter = None # OptionalExprContext
@@ -5017,8 +5771,9 @@ class Parser(Parser):
5017
5771
 
5018
5772
  class UnaryStringFunctionContext(StringOperatorsContext):
5019
5773
 
5020
- def __init__(self, parser,
5021
- ctx: ParserRuleContext): # actually a VtlParser.StringOperatorsContext
5774
+ def __init__(
5775
+ self, parser, ctx: ParserRuleContext
5776
+ ): # actually a VtlParser.StringOperatorsContext
5022
5777
  super().__init__(parser)
5023
5778
  self.op = None # Token
5024
5779
  self.copyFrom(ctx)
@@ -5058,8 +5813,9 @@ class Parser(Parser):
5058
5813
 
5059
5814
  class SubstrAtomContext(StringOperatorsContext):
5060
5815
 
5061
- def __init__(self, parser,
5062
- ctx: ParserRuleContext): # actually a VtlParser.StringOperatorsContext
5816
+ def __init__(
5817
+ self, parser, ctx: ParserRuleContext
5818
+ ): # actually a VtlParser.StringOperatorsContext
5063
5819
  super().__init__(parser)
5064
5820
  self.startParameter = None # OptionalExprContext
5065
5821
  self.endParameter = None # OptionalExprContext
@@ -5097,8 +5853,9 @@ class Parser(Parser):
5097
5853
 
5098
5854
  class ReplaceAtomContext(StringOperatorsContext):
5099
5855
 
5100
- def __init__(self, parser,
5101
- ctx: ParserRuleContext): # actually a VtlParser.StringOperatorsContext
5856
+ def __init__(
5857
+ self, parser, ctx: ParserRuleContext
5858
+ ): # actually a VtlParser.StringOperatorsContext
5102
5859
  super().__init__(parser)
5103
5860
  self.param = None # ExprContext
5104
5861
  self.copyFrom(ctx)
@@ -5142,17 +5899,36 @@ class Parser(Parser):
5142
5899
  self.state = 664
5143
5900
  self._errHandler.sync(self)
5144
5901
  token = self._input.LA(1)
5145
- if token in [Parser.LEN, Parser.TRIM, Parser.UCASE, Parser.LCASE, Parser.LTRIM,
5146
- Parser.RTRIM]:
5902
+ if token in [
5903
+ Parser.LEN,
5904
+ Parser.TRIM,
5905
+ Parser.UCASE,
5906
+ Parser.LCASE,
5907
+ Parser.LTRIM,
5908
+ Parser.RTRIM,
5909
+ ]:
5147
5910
  localctx = Parser.UnaryStringFunctionContext(self, localctx)
5148
5911
  self.enterOuterAlt(localctx, 1)
5149
5912
  self.state = 616
5150
5913
  localctx.op = self._input.LT(1)
5151
5914
  _la = self._input.LA(1)
5152
- if not (((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & (
5153
- (1 << (Parser.LEN - 81)) | (1 << (Parser.TRIM - 81)) | (
5154
- 1 << (Parser.UCASE - 81)) | (1 << (Parser.LCASE - 81)) | (
5155
- 1 << (Parser.LTRIM - 81)) | (1 << (Parser.RTRIM - 81)))) != 0)):
5915
+ if not (
5916
+ (
5917
+ (((_la - 81)) & ~0x3F) == 0
5918
+ and (
5919
+ (1 << (_la - 81))
5920
+ & (
5921
+ (1 << (Parser.LEN - 81))
5922
+ | (1 << (Parser.TRIM - 81))
5923
+ | (1 << (Parser.UCASE - 81))
5924
+ | (1 << (Parser.LCASE - 81))
5925
+ | (1 << (Parser.LTRIM - 81))
5926
+ | (1 << (Parser.RTRIM - 81))
5927
+ )
5928
+ )
5929
+ != 0
5930
+ )
5931
+ ):
5156
5932
  localctx.op = self._errHandler.recoverInline(self)
5157
5933
  else:
5158
5934
  self._errHandler.reportMatch(self)
@@ -5287,8 +6063,9 @@ class Parser(Parser):
5287
6063
 
5288
6064
  class ReplaceAtomComponentContext(StringOperatorsComponentContext):
5289
6065
 
5290
- def __init__(self, parser,
5291
- ctx: ParserRuleContext): # actually a VtlParser.StringOperatorsComponentContext
6066
+ def __init__(
6067
+ self, parser, ctx: ParserRuleContext
6068
+ ): # actually a VtlParser.StringOperatorsComponentContext
5292
6069
  super().__init__(parser)
5293
6070
  self.param = None # ExprComponentContext
5294
6071
  self.copyFrom(ctx)
@@ -5325,8 +6102,9 @@ class Parser(Parser):
5325
6102
 
5326
6103
  class UnaryStringFunctionComponentContext(StringOperatorsComponentContext):
5327
6104
 
5328
- def __init__(self, parser,
5329
- ctx: ParserRuleContext): # actually a VtlParser.StringOperatorsComponentContext
6105
+ def __init__(
6106
+ self, parser, ctx: ParserRuleContext
6107
+ ): # actually a VtlParser.StringOperatorsComponentContext
5330
6108
  super().__init__(parser)
5331
6109
  self.op = None # Token
5332
6110
  self.copyFrom(ctx)
@@ -5366,8 +6144,9 @@ class Parser(Parser):
5366
6144
 
5367
6145
  class SubstrAtomComponentContext(StringOperatorsComponentContext):
5368
6146
 
5369
- def __init__(self, parser,
5370
- ctx: ParserRuleContext): # actually a VtlParser.StringOperatorsComponentContext
6147
+ def __init__(
6148
+ self, parser, ctx: ParserRuleContext
6149
+ ): # actually a VtlParser.StringOperatorsComponentContext
5371
6150
  super().__init__(parser)
5372
6151
  self.startParameter = None # OptionalExprComponentContext
5373
6152
  self.endParameter = None # OptionalExprComponentContext
@@ -5405,8 +6184,9 @@ class Parser(Parser):
5405
6184
 
5406
6185
  class InstrAtomComponentContext(StringOperatorsComponentContext):
5407
6186
 
5408
- def __init__(self, parser,
5409
- ctx: ParserRuleContext): # actually a VtlParser.StringOperatorsComponentContext
6187
+ def __init__(
6188
+ self, parser, ctx: ParserRuleContext
6189
+ ): # actually a VtlParser.StringOperatorsComponentContext
5410
6190
  super().__init__(parser)
5411
6191
  self.pattern = None # ExprComponentContext
5412
6192
  self.startParameter = None # OptionalExprComponentContext
@@ -5455,17 +6235,36 @@ class Parser(Parser):
5455
6235
  self.state = 714
5456
6236
  self._errHandler.sync(self)
5457
6237
  token = self._input.LA(1)
5458
- if token in [Parser.LEN, Parser.TRIM, Parser.UCASE, Parser.LCASE, Parser.LTRIM,
5459
- Parser.RTRIM]:
6238
+ if token in [
6239
+ Parser.LEN,
6240
+ Parser.TRIM,
6241
+ Parser.UCASE,
6242
+ Parser.LCASE,
6243
+ Parser.LTRIM,
6244
+ Parser.RTRIM,
6245
+ ]:
5460
6246
  localctx = Parser.UnaryStringFunctionComponentContext(self, localctx)
5461
6247
  self.enterOuterAlt(localctx, 1)
5462
6248
  self.state = 666
5463
6249
  localctx.op = self._input.LT(1)
5464
6250
  _la = self._input.LA(1)
5465
- if not (((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & (
5466
- (1 << (Parser.LEN - 81)) | (1 << (Parser.TRIM - 81)) | (
5467
- 1 << (Parser.UCASE - 81)) | (1 << (Parser.LCASE - 81)) | (
5468
- 1 << (Parser.LTRIM - 81)) | (1 << (Parser.RTRIM - 81)))) != 0)):
6251
+ if not (
6252
+ (
6253
+ (((_la - 81)) & ~0x3F) == 0
6254
+ and (
6255
+ (1 << (_la - 81))
6256
+ & (
6257
+ (1 << (Parser.LEN - 81))
6258
+ | (1 << (Parser.TRIM - 81))
6259
+ | (1 << (Parser.UCASE - 81))
6260
+ | (1 << (Parser.LCASE - 81))
6261
+ | (1 << (Parser.LTRIM - 81))
6262
+ | (1 << (Parser.RTRIM - 81))
6263
+ )
6264
+ )
6265
+ != 0
6266
+ )
6267
+ ):
5469
6268
  localctx.op = self._errHandler.recoverInline(self)
5470
6269
  else:
5471
6270
  self._errHandler.reportMatch(self)
@@ -5600,8 +6399,9 @@ class Parser(Parser):
5600
6399
 
5601
6400
  class UnaryNumericContext(NumericOperatorsContext):
5602
6401
 
5603
- def __init__(self, parser,
5604
- ctx: ParserRuleContext): # actually a VtlParser.NumericOperatorsContext
6402
+ def __init__(
6403
+ self, parser, ctx: ParserRuleContext
6404
+ ): # actually a VtlParser.NumericOperatorsContext
5605
6405
  super().__init__(parser)
5606
6406
  self.op = None # Token
5607
6407
  self.copyFrom(ctx)
@@ -5641,8 +6441,9 @@ class Parser(Parser):
5641
6441
 
5642
6442
  class UnaryWithOptionalNumericContext(NumericOperatorsContext):
5643
6443
 
5644
- def __init__(self, parser,
5645
- ctx: ParserRuleContext): # actually a VtlParser.NumericOperatorsContext
6444
+ def __init__(
6445
+ self, parser, ctx: ParserRuleContext
6446
+ ): # actually a VtlParser.NumericOperatorsContext
5646
6447
  super().__init__(parser)
5647
6448
  self.op = None # Token
5648
6449
  self.copyFrom(ctx)
@@ -5676,8 +6477,9 @@ class Parser(Parser):
5676
6477
 
5677
6478
  class BinaryNumericContext(NumericOperatorsContext):
5678
6479
 
5679
- def __init__(self, parser,
5680
- ctx: ParserRuleContext): # actually a VtlParser.NumericOperatorsContext
6480
+ def __init__(
6481
+ self, parser, ctx: ParserRuleContext
6482
+ ): # actually a VtlParser.NumericOperatorsContext
5681
6483
  super().__init__(parser)
5682
6484
  self.op = None # Token
5683
6485
  self.left = None # ExprContext
@@ -5729,10 +6531,23 @@ class Parser(Parser):
5729
6531
  self.state = 716
5730
6532
  localctx.op = self._input.LT(1)
5731
6533
  _la = self._input.LA(1)
5732
- if not (((((_la - 73)) & ~0x3f) == 0 and ((1 << (_la - 73)) & (
5733
- (1 << (Parser.ABS - 73)) | (1 << (Parser.LN - 73)) | (
5734
- 1 << (Parser.EXP - 73)) | (1 << (Parser.CEIL - 73)) | (
5735
- 1 << (Parser.FLOOR - 73)) | (1 << (Parser.SQRT - 73)))) != 0)):
6534
+ if not (
6535
+ (
6536
+ (((_la - 73)) & ~0x3F) == 0
6537
+ and (
6538
+ (1 << (_la - 73))
6539
+ & (
6540
+ (1 << (Parser.ABS - 73))
6541
+ | (1 << (Parser.LN - 73))
6542
+ | (1 << (Parser.EXP - 73))
6543
+ | (1 << (Parser.CEIL - 73))
6544
+ | (1 << (Parser.FLOOR - 73))
6545
+ | (1 << (Parser.SQRT - 73))
6546
+ )
6547
+ )
6548
+ != 0
6549
+ )
6550
+ ):
5736
6551
  localctx.op = self._errHandler.recoverInline(self)
5737
6552
  else:
5738
6553
  self._errHandler.reportMatch(self)
@@ -5777,9 +6592,20 @@ class Parser(Parser):
5777
6592
  self.state = 730
5778
6593
  localctx.op = self._input.LT(1)
5779
6594
  _la = self._input.LA(1)
5780
- if not (((((_la - 76)) & ~0x3f) == 0 and ((1 << (_la - 76)) & (
5781
- (1 << (Parser.LOG - 76)) | (1 << (Parser.POWER - 76)) | (
5782
- 1 << (Parser.MOD - 76)))) != 0)):
6595
+ if not (
6596
+ (
6597
+ (((_la - 76)) & ~0x3F) == 0
6598
+ and (
6599
+ (1 << (_la - 76))
6600
+ & (
6601
+ (1 << (Parser.LOG - 76))
6602
+ | (1 << (Parser.POWER - 76))
6603
+ | (1 << (Parser.MOD - 76))
6604
+ )
6605
+ )
6606
+ != 0
6607
+ )
6608
+ ):
5783
6609
  localctx.op = self._errHandler.recoverInline(self)
5784
6610
  else:
5785
6611
  self._errHandler.reportMatch(self)
@@ -5820,8 +6646,9 @@ class Parser(Parser):
5820
6646
 
5821
6647
  class UnaryNumericComponentContext(NumericOperatorsComponentContext):
5822
6648
 
5823
- def __init__(self, parser,
5824
- ctx: ParserRuleContext): # actually a VtlParser.NumericOperatorsComponentContext
6649
+ def __init__(
6650
+ self, parser, ctx: ParserRuleContext
6651
+ ): # actually a VtlParser.NumericOperatorsComponentContext
5825
6652
  super().__init__(parser)
5826
6653
  self.op = None # Token
5827
6654
  self.copyFrom(ctx)
@@ -5861,8 +6688,9 @@ class Parser(Parser):
5861
6688
 
5862
6689
  class BinaryNumericComponentContext(NumericOperatorsComponentContext):
5863
6690
 
5864
- def __init__(self, parser,
5865
- ctx: ParserRuleContext): # actually a VtlParser.NumericOperatorsComponentContext
6691
+ def __init__(
6692
+ self, parser, ctx: ParserRuleContext
6693
+ ): # actually a VtlParser.NumericOperatorsComponentContext
5866
6694
  super().__init__(parser)
5867
6695
  self.op = None # Token
5868
6696
  self.left = None # ExprComponentContext
@@ -5901,8 +6729,9 @@ class Parser(Parser):
5901
6729
 
5902
6730
  class UnaryWithOptionalNumericComponentContext(NumericOperatorsComponentContext):
5903
6731
 
5904
- def __init__(self, parser,
5905
- ctx: ParserRuleContext): # actually a VtlParser.NumericOperatorsComponentContext
6732
+ def __init__(
6733
+ self, parser, ctx: ParserRuleContext
6734
+ ): # actually a VtlParser.NumericOperatorsComponentContext
5906
6735
  super().__init__(parser)
5907
6736
  self.op = None # Token
5908
6737
  self.copyFrom(ctx)
@@ -5949,10 +6778,23 @@ class Parser(Parser):
5949
6778
  self.state = 739
5950
6779
  localctx.op = self._input.LT(1)
5951
6780
  _la = self._input.LA(1)
5952
- if not (((((_la - 73)) & ~0x3f) == 0 and ((1 << (_la - 73)) & (
5953
- (1 << (Parser.ABS - 73)) | (1 << (Parser.LN - 73)) | (
5954
- 1 << (Parser.EXP - 73)) | (1 << (Parser.CEIL - 73)) | (
5955
- 1 << (Parser.FLOOR - 73)) | (1 << (Parser.SQRT - 73)))) != 0)):
6781
+ if not (
6782
+ (
6783
+ (((_la - 73)) & ~0x3F) == 0
6784
+ and (
6785
+ (1 << (_la - 73))
6786
+ & (
6787
+ (1 << (Parser.ABS - 73))
6788
+ | (1 << (Parser.LN - 73))
6789
+ | (1 << (Parser.EXP - 73))
6790
+ | (1 << (Parser.CEIL - 73))
6791
+ | (1 << (Parser.FLOOR - 73))
6792
+ | (1 << (Parser.SQRT - 73))
6793
+ )
6794
+ )
6795
+ != 0
6796
+ )
6797
+ ):
5956
6798
  localctx.op = self._errHandler.recoverInline(self)
5957
6799
  else:
5958
6800
  self._errHandler.reportMatch(self)
@@ -5997,9 +6839,20 @@ class Parser(Parser):
5997
6839
  self.state = 753
5998
6840
  localctx.op = self._input.LT(1)
5999
6841
  _la = self._input.LA(1)
6000
- if not (((((_la - 76)) & ~0x3f) == 0 and ((1 << (_la - 76)) & (
6001
- (1 << (Parser.LOG - 76)) | (1 << (Parser.POWER - 76)) | (
6002
- 1 << (Parser.MOD - 76)))) != 0)):
6842
+ if not (
6843
+ (
6844
+ (((_la - 76)) & ~0x3F) == 0
6845
+ and (
6846
+ (1 << (_la - 76))
6847
+ & (
6848
+ (1 << (Parser.LOG - 76))
6849
+ | (1 << (Parser.POWER - 76))
6850
+ | (1 << (Parser.MOD - 76))
6851
+ )
6852
+ )
6853
+ != 0
6854
+ )
6855
+ ):
6003
6856
  localctx.op = self._errHandler.recoverInline(self)
6004
6857
  else:
6005
6858
  self._errHandler.reportMatch(self)
@@ -6040,8 +6893,9 @@ class Parser(Parser):
6040
6893
 
6041
6894
  class BetweenAtomContext(ComparisonOperatorsContext):
6042
6895
 
6043
- def __init__(self, parser,
6044
- ctx: ParserRuleContext): # actually a VtlParser.ComparisonOperatorsContext
6896
+ def __init__(
6897
+ self, parser, ctx: ParserRuleContext
6898
+ ): # actually a VtlParser.ComparisonOperatorsContext
6045
6899
  super().__init__(parser)
6046
6900
  self.op = None # ExprContext
6047
6901
  self.from_ = None # ExprContext
@@ -6077,8 +6931,9 @@ class Parser(Parser):
6077
6931
 
6078
6932
  class CharsetMatchAtomContext(ComparisonOperatorsContext):
6079
6933
 
6080
- def __init__(self, parser,
6081
- ctx: ParserRuleContext): # actually a VtlParser.ComparisonOperatorsContext
6934
+ def __init__(
6935
+ self, parser, ctx: ParserRuleContext
6936
+ ): # actually a VtlParser.ComparisonOperatorsContext
6082
6937
  super().__init__(parser)
6083
6938
  self.op = None # ExprContext
6084
6939
  self.pattern = None # ExprContext
@@ -6110,8 +6965,9 @@ class Parser(Parser):
6110
6965
 
6111
6966
  class IsNullAtomContext(ComparisonOperatorsContext):
6112
6967
 
6113
- def __init__(self, parser,
6114
- ctx: ParserRuleContext): # actually a VtlParser.ComparisonOperatorsContext
6968
+ def __init__(
6969
+ self, parser, ctx: ParserRuleContext
6970
+ ): # actually a VtlParser.ComparisonOperatorsContext
6115
6971
  super().__init__(parser)
6116
6972
  self.copyFrom(ctx)
6117
6973
 
@@ -6135,8 +6991,9 @@ class Parser(Parser):
6135
6991
 
6136
6992
  class ExistInAtomContext(ComparisonOperatorsContext):
6137
6993
 
6138
- def __init__(self, parser,
6139
- ctx: ParserRuleContext): # actually a VtlParser.ComparisonOperatorsContext
6994
+ def __init__(
6995
+ self, parser, ctx: ParserRuleContext
6996
+ ): # actually a VtlParser.ComparisonOperatorsContext
6140
6997
  super().__init__(parser)
6141
6998
  self.left = None # ExprContext
6142
6999
  self.right = None # ExprContext
@@ -6279,8 +7136,9 @@ class Parser(Parser):
6279
7136
 
6280
7137
  class IsNullAtomComponentContext(ComparisonOperatorsComponentContext):
6281
7138
 
6282
- def __init__(self, parser,
6283
- ctx: ParserRuleContext): # actually a VtlParser.ComparisonOperatorsComponentContext
7139
+ def __init__(
7140
+ self, parser, ctx: ParserRuleContext
7141
+ ): # actually a VtlParser.ComparisonOperatorsComponentContext
6284
7142
  super().__init__(parser)
6285
7143
  self.copyFrom(ctx)
6286
7144
 
@@ -6304,8 +7162,9 @@ class Parser(Parser):
6304
7162
 
6305
7163
  class CharsetMatchAtomComponentContext(ComparisonOperatorsComponentContext):
6306
7164
 
6307
- def __init__(self, parser,
6308
- ctx: ParserRuleContext): # actually a VtlParser.ComparisonOperatorsComponentContext
7165
+ def __init__(
7166
+ self, parser, ctx: ParserRuleContext
7167
+ ): # actually a VtlParser.ComparisonOperatorsComponentContext
6309
7168
  super().__init__(parser)
6310
7169
  self.op = None # ExprComponentContext
6311
7170
  self.pattern = None # ExprComponentContext
@@ -6337,8 +7196,9 @@ class Parser(Parser):
6337
7196
 
6338
7197
  class BetweenAtomComponentContext(ComparisonOperatorsComponentContext):
6339
7198
 
6340
- def __init__(self, parser,
6341
- ctx: ParserRuleContext): # actually a VtlParser.ComparisonOperatorsComponentContext
7199
+ def __init__(
7200
+ self, parser, ctx: ParserRuleContext
7201
+ ): # actually a VtlParser.ComparisonOperatorsComponentContext
6342
7202
  super().__init__(parser)
6343
7203
  self.op = None # ExprComponentContext
6344
7204
  self.from_ = None # ExprComponentContext
@@ -6453,8 +7313,9 @@ class Parser(Parser):
6453
7313
 
6454
7314
  class FlowAtomContext(TimeOperatorsContext):
6455
7315
 
6456
- def __init__(self, parser,
6457
- ctx: ParserRuleContext): # actually a VtlParser.TimeOperatorsContext
7316
+ def __init__(
7317
+ self, parser, ctx: ParserRuleContext
7318
+ ): # actually a VtlParser.TimeOperatorsContext
6458
7319
  super().__init__(parser)
6459
7320
  self.op = None # Token
6460
7321
  self.copyFrom(ctx)
@@ -6482,8 +7343,9 @@ class Parser(Parser):
6482
7343
 
6483
7344
  class TimeShiftAtomContext(TimeOperatorsContext):
6484
7345
 
6485
- def __init__(self, parser,
6486
- ctx: ParserRuleContext): # actually a VtlParser.TimeOperatorsContext
7346
+ def __init__(
7347
+ self, parser, ctx: ParserRuleContext
7348
+ ): # actually a VtlParser.TimeOperatorsContext
6487
7349
  super().__init__(parser)
6488
7350
  self.copyFrom(ctx)
6489
7351
 
@@ -6513,8 +7375,9 @@ class Parser(Parser):
6513
7375
 
6514
7376
  class TimeAggAtomContext(TimeOperatorsContext):
6515
7377
 
6516
- def __init__(self, parser,
6517
- ctx: ParserRuleContext): # actually a VtlParser.TimeOperatorsContext
7378
+ def __init__(
7379
+ self, parser, ctx: ParserRuleContext
7380
+ ): # actually a VtlParser.TimeOperatorsContext
6518
7381
  super().__init__(parser)
6519
7382
  self.periodIndTo = None # Token
6520
7383
  self.periodIndFrom = None # Token
@@ -6562,8 +7425,9 @@ class Parser(Parser):
6562
7425
 
6563
7426
  class CurrentDateAtomContext(TimeOperatorsContext):
6564
7427
 
6565
- def __init__(self, parser,
6566
- ctx: ParserRuleContext): # actually a VtlParser.TimeOperatorsContext
7428
+ def __init__(
7429
+ self, parser, ctx: ParserRuleContext
7430
+ ): # actually a VtlParser.TimeOperatorsContext
6567
7431
  super().__init__(parser)
6568
7432
  self.copyFrom(ctx)
6569
7433
 
@@ -6584,8 +7448,9 @@ class Parser(Parser):
6584
7448
 
6585
7449
  class PeriodAtomContext(TimeOperatorsContext):
6586
7450
 
6587
- def __init__(self, parser,
6588
- ctx: ParserRuleContext): # actually a VtlParser.TimeOperatorsContext
7451
+ def __init__(
7452
+ self, parser, ctx: ParserRuleContext
7453
+ ): # actually a VtlParser.TimeOperatorsContext
6589
7454
  super().__init__(parser)
6590
7455
  self.copyFrom(ctx)
6591
7456
 
@@ -6609,8 +7474,9 @@ class Parser(Parser):
6609
7474
 
6610
7475
  class FillTimeAtomContext(TimeOperatorsContext):
6611
7476
 
6612
- def __init__(self, parser,
6613
- ctx: ParserRuleContext): # actually a VtlParser.TimeOperatorsContext
7477
+ def __init__(
7478
+ self, parser, ctx: ParserRuleContext
7479
+ ): # actually a VtlParser.TimeOperatorsContext
6614
7480
  super().__init__(parser)
6615
7481
  self.copyFrom(ctx)
6616
7482
 
@@ -6660,68 +7526,116 @@ class Parser(Parser):
6660
7526
  self.state = 822
6661
7527
  self._errHandler.sync(self)
6662
7528
  _la = self._input.LA(1)
6663
- if (((_la) & ~0x3f) == 0 and ((1 << _la) & (
6664
- (1 << Parser.LPAREN) | (1 << Parser.PLUS) | (1 << Parser.MINUS) | (
6665
- 1 << Parser.EVAL) | (1 << Parser.IF) | (1 << Parser.CURRENT_DATE) | (
6666
- 1 << Parser.NOT) | (1 << Parser.BETWEEN) | (
6667
- 1 << Parser.NULL_CONSTANT) | (1 << Parser.ISNULL) | (
6668
- 1 << Parser.UNION) | (1 << Parser.SYMDIFF) | (
6669
- 1 << Parser.INTERSECT) | (1 << Parser.CHECK) | (
6670
- 1 << Parser.EXISTS_IN))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and (
6671
- (1 << (_la - 68)) & ((1 << (Parser.MIN - 68)) | (1 << (Parser.MAX - 68)) | (
6672
- 1 << (Parser.ABS - 68)) | (1 << (Parser.LN - 68)) | (
6673
- 1 << (Parser.LOG - 68)) | (
6674
- 1 << (Parser.TRUNC - 68)) | (
6675
- 1 << (Parser.ROUND - 68)) | (
6676
- 1 << (Parser.POWER - 68)) | (
6677
- 1 << (Parser.MOD - 68)) | (
6678
- 1 << (Parser.LEN - 68)) | (
6679
- 1 << (Parser.TRIM - 68)) | (
6680
- 1 << (Parser.UCASE - 68)) | (
6681
- 1 << (Parser.LCASE - 68)) | (
6682
- 1 << (Parser.SUBSTR - 68)) | (
6683
- 1 << (Parser.SUM - 68)) | (
6684
- 1 << (Parser.AVG - 68)) | (
6685
- 1 << (Parser.MEDIAN - 68)) | (
6686
- 1 << (Parser.COUNT - 68)) | (
6687
- 1 << (Parser.EXP - 68)) | (
6688
- 1 << (Parser.CHARSET_MATCH - 68)) | (
6689
- 1 << (Parser.NVL - 68)) | (
6690
- 1 << (Parser.HIERARCHY - 68)) | (
6691
- 1 << (Parser.LTRIM - 68)) | (
6692
- 1 << (Parser.RTRIM - 68)) | (
6693
- 1 << (Parser.INSTR - 68)) | (
6694
- 1 << (Parser.REPLACE - 68)) | (
6695
- 1 << (Parser.CEIL - 68)) | (
6696
- 1 << (Parser.FLOOR - 68)) | (
6697
- 1 << (Parser.SQRT - 68)) | (
6698
- 1 << (Parser.SETDIFF - 68)) | (
6699
- 1 << (Parser.STDDEV_POP - 68)) | (
6700
- 1 << (Parser.STDDEV_SAMP - 68)) | (
6701
- 1 << (Parser.VAR_POP - 68)) | (
6702
- 1 << (Parser.VAR_SAMP - 68)))) != 0) or (
6703
- (((_la - 135)) & ~0x3f) == 0 and ((1 << (_la - 135)) & (
6704
- (1 << (Parser.FIRST_VALUE - 135)) | (1 << (Parser.LAST_VALUE - 135)) | (
6705
- 1 << (Parser.LAG - 135)) | (1 << (Parser.LEAD - 135)) | (
6706
- 1 << (Parser.RATIO_TO_REPORT - 135)) | (
6707
- 1 << (Parser.FILL_TIME_SERIES - 135)) | (
6708
- 1 << (Parser.FLOW_TO_STOCK - 135)) | (
6709
- 1 << (Parser.STOCK_TO_FLOW - 135)) | (
6710
- 1 << (Parser.TIMESHIFT - 135)) | (
6711
- 1 << (Parser.INNER_JOIN - 135)) | (
6712
- 1 << (Parser.LEFT_JOIN - 135)) | (
6713
- 1 << (Parser.CROSS_JOIN - 135)) | (
6714
- 1 << (Parser.FULL_JOIN - 135)) | (
6715
- 1 << (Parser.PERIOD_INDICATOR - 135)))) != 0) or (
6716
- (((_la - 199)) & ~0x3f) == 0 and ((1 << (_la - 199)) & (
6717
- (1 << (Parser.TIME_AGG - 199)) | (1 << (Parser.CAST - 199)) | (
6718
- 1 << (Parser.CHECK_DATAPOINT - 199)) | (
6719
- 1 << (Parser.CHECK_HIERARCHY - 199)) | (
6720
- 1 << (Parser.INTEGER_CONSTANT - 199)) | (
6721
- 1 << (Parser.NUMBER_CONSTANT - 199)) | (
6722
- 1 << (Parser.BOOLEAN_CONSTANT - 199)) | (
6723
- 1 << (Parser.STRING_CONSTANT - 199)) | (
6724
- 1 << (Parser.IDENTIFIER - 199)))) != 0):
7529
+ if (
7530
+ (
7531
+ ((_la) & ~0x3F) == 0
7532
+ and (
7533
+ (1 << _la)
7534
+ & (
7535
+ (1 << Parser.LPAREN)
7536
+ | (1 << Parser.PLUS)
7537
+ | (1 << Parser.MINUS)
7538
+ | (1 << Parser.EVAL)
7539
+ | (1 << Parser.IF)
7540
+ | (1 << Parser.CURRENT_DATE)
7541
+ | (1 << Parser.NOT)
7542
+ | (1 << Parser.BETWEEN)
7543
+ | (1 << Parser.NULL_CONSTANT)
7544
+ | (1 << Parser.ISNULL)
7545
+ | (1 << Parser.UNION)
7546
+ | (1 << Parser.SYMDIFF)
7547
+ | (1 << Parser.INTERSECT)
7548
+ | (1 << Parser.CHECK)
7549
+ | (1 << Parser.EXISTS_IN)
7550
+ )
7551
+ )
7552
+ != 0
7553
+ )
7554
+ or (
7555
+ (((_la - 68)) & ~0x3F) == 0
7556
+ and (
7557
+ (1 << (_la - 68))
7558
+ & (
7559
+ (1 << (Parser.MIN - 68))
7560
+ | (1 << (Parser.MAX - 68))
7561
+ | (1 << (Parser.ABS - 68))
7562
+ | (1 << (Parser.LN - 68))
7563
+ | (1 << (Parser.LOG - 68))
7564
+ | (1 << (Parser.TRUNC - 68))
7565
+ | (1 << (Parser.ROUND - 68))
7566
+ | (1 << (Parser.POWER - 68))
7567
+ | (1 << (Parser.MOD - 68))
7568
+ | (1 << (Parser.LEN - 68))
7569
+ | (1 << (Parser.TRIM - 68))
7570
+ | (1 << (Parser.UCASE - 68))
7571
+ | (1 << (Parser.LCASE - 68))
7572
+ | (1 << (Parser.SUBSTR - 68))
7573
+ | (1 << (Parser.SUM - 68))
7574
+ | (1 << (Parser.AVG - 68))
7575
+ | (1 << (Parser.MEDIAN - 68))
7576
+ | (1 << (Parser.COUNT - 68))
7577
+ | (1 << (Parser.EXP - 68))
7578
+ | (1 << (Parser.CHARSET_MATCH - 68))
7579
+ | (1 << (Parser.NVL - 68))
7580
+ | (1 << (Parser.HIERARCHY - 68))
7581
+ | (1 << (Parser.LTRIM - 68))
7582
+ | (1 << (Parser.RTRIM - 68))
7583
+ | (1 << (Parser.INSTR - 68))
7584
+ | (1 << (Parser.REPLACE - 68))
7585
+ | (1 << (Parser.CEIL - 68))
7586
+ | (1 << (Parser.FLOOR - 68))
7587
+ | (1 << (Parser.SQRT - 68))
7588
+ | (1 << (Parser.SETDIFF - 68))
7589
+ | (1 << (Parser.STDDEV_POP - 68))
7590
+ | (1 << (Parser.STDDEV_SAMP - 68))
7591
+ | (1 << (Parser.VAR_POP - 68))
7592
+ | (1 << (Parser.VAR_SAMP - 68))
7593
+ )
7594
+ )
7595
+ != 0
7596
+ )
7597
+ or (
7598
+ (((_la - 135)) & ~0x3F) == 0
7599
+ and (
7600
+ (1 << (_la - 135))
7601
+ & (
7602
+ (1 << (Parser.FIRST_VALUE - 135))
7603
+ | (1 << (Parser.LAST_VALUE - 135))
7604
+ | (1 << (Parser.LAG - 135))
7605
+ | (1 << (Parser.LEAD - 135))
7606
+ | (1 << (Parser.RATIO_TO_REPORT - 135))
7607
+ | (1 << (Parser.FILL_TIME_SERIES - 135))
7608
+ | (1 << (Parser.FLOW_TO_STOCK - 135))
7609
+ | (1 << (Parser.STOCK_TO_FLOW - 135))
7610
+ | (1 << (Parser.TIMESHIFT - 135))
7611
+ | (1 << (Parser.INNER_JOIN - 135))
7612
+ | (1 << (Parser.LEFT_JOIN - 135))
7613
+ | (1 << (Parser.CROSS_JOIN - 135))
7614
+ | (1 << (Parser.FULL_JOIN - 135))
7615
+ | (1 << (Parser.PERIOD_INDICATOR - 135))
7616
+ )
7617
+ )
7618
+ != 0
7619
+ )
7620
+ or (
7621
+ (((_la - 199)) & ~0x3F) == 0
7622
+ and (
7623
+ (1 << (_la - 199))
7624
+ & (
7625
+ (1 << (Parser.TIME_AGG - 199))
7626
+ | (1 << (Parser.CAST - 199))
7627
+ | (1 << (Parser.CHECK_DATAPOINT - 199))
7628
+ | (1 << (Parser.CHECK_HIERARCHY - 199))
7629
+ | (1 << (Parser.INTEGER_CONSTANT - 199))
7630
+ | (1 << (Parser.NUMBER_CONSTANT - 199))
7631
+ | (1 << (Parser.BOOLEAN_CONSTANT - 199))
7632
+ | (1 << (Parser.STRING_CONSTANT - 199))
7633
+ | (1 << (Parser.IDENTIFIER - 199))
7634
+ )
7635
+ )
7636
+ != 0
7637
+ )
7638
+ ):
6725
7639
  self.state = 821
6726
7640
  self.expr(0)
6727
7641
 
@@ -6873,8 +7787,9 @@ class Parser(Parser):
6873
7787
 
6874
7788
  class PeriodAtomComponentContext(TimeOperatorsComponentContext):
6875
7789
 
6876
- def __init__(self, parser,
6877
- ctx: ParserRuleContext): # actually a VtlParser.TimeOperatorsComponentContext
7790
+ def __init__(
7791
+ self, parser, ctx: ParserRuleContext
7792
+ ): # actually a VtlParser.TimeOperatorsComponentContext
6878
7793
  super().__init__(parser)
6879
7794
  self.copyFrom(ctx)
6880
7795
 
@@ -6898,8 +7813,9 @@ class Parser(Parser):
6898
7813
 
6899
7814
  class TimeShiftAtomComponentContext(TimeOperatorsComponentContext):
6900
7815
 
6901
- def __init__(self, parser,
6902
- ctx: ParserRuleContext): # actually a VtlParser.TimeOperatorsComponentContext
7816
+ def __init__(
7817
+ self, parser, ctx: ParserRuleContext
7818
+ ): # actually a VtlParser.TimeOperatorsComponentContext
6903
7819
  super().__init__(parser)
6904
7820
  self.copyFrom(ctx)
6905
7821
 
@@ -6929,8 +7845,9 @@ class Parser(Parser):
6929
7845
 
6930
7846
  class TimeAggAtomComponentContext(TimeOperatorsComponentContext):
6931
7847
 
6932
- def __init__(self, parser,
6933
- ctx: ParserRuleContext): # actually a VtlParser.TimeOperatorsComponentContext
7848
+ def __init__(
7849
+ self, parser, ctx: ParserRuleContext
7850
+ ): # actually a VtlParser.TimeOperatorsComponentContext
6934
7851
  super().__init__(parser)
6935
7852
  self.periodIndTo = None # Token
6936
7853
  self.periodIndFrom = None # Token
@@ -6978,8 +7895,9 @@ class Parser(Parser):
6978
7895
 
6979
7896
  class CurrentDateAtomComponentContext(TimeOperatorsComponentContext):
6980
7897
 
6981
- def __init__(self, parser,
6982
- ctx: ParserRuleContext): # actually a VtlParser.TimeOperatorsComponentContext
7898
+ def __init__(
7899
+ self, parser, ctx: ParserRuleContext
7900
+ ): # actually a VtlParser.TimeOperatorsComponentContext
6983
7901
  super().__init__(parser)
6984
7902
  self.copyFrom(ctx)
6985
7903
 
@@ -7000,8 +7918,9 @@ class Parser(Parser):
7000
7918
 
7001
7919
  class FlowAtomComponentContext(TimeOperatorsComponentContext):
7002
7920
 
7003
- def __init__(self, parser,
7004
- ctx: ParserRuleContext): # actually a VtlParser.TimeOperatorsComponentContext
7921
+ def __init__(
7922
+ self, parser, ctx: ParserRuleContext
7923
+ ): # actually a VtlParser.TimeOperatorsComponentContext
7005
7924
  super().__init__(parser)
7006
7925
  self.op = None # Token
7007
7926
  self.copyFrom(ctx)
@@ -7029,8 +7948,9 @@ class Parser(Parser):
7029
7948
 
7030
7949
  class FillTimeAtomComponentContext(TimeOperatorsComponentContext):
7031
7950
 
7032
- def __init__(self, parser,
7033
- ctx: ParserRuleContext): # actually a VtlParser.TimeOperatorsComponentContext
7951
+ def __init__(
7952
+ self, parser, ctx: ParserRuleContext
7953
+ ): # actually a VtlParser.TimeOperatorsComponentContext
7034
7954
  super().__init__(parser)
7035
7955
  self.copyFrom(ctx)
7036
7956
 
@@ -7080,45 +8000,104 @@ class Parser(Parser):
7080
8000
  self.state = 870
7081
8001
  self._errHandler.sync(self)
7082
8002
  _la = self._input.LA(1)
7083
- if (((_la) & ~0x3f) == 0 and ((1 << _la) & (
7084
- (1 << Parser.LPAREN) | (1 << Parser.PLUS) | (1 << Parser.MINUS) | (
7085
- 1 << Parser.EVAL) | (1 << Parser.IF) | (1 << Parser.CURRENT_DATE) | (
7086
- 1 << Parser.NOT) | (1 << Parser.BETWEEN) | (
7087
- 1 << Parser.NULL_CONSTANT) | (1 << Parser.ISNULL))) != 0) or (
7088
- (((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & (
7089
- (1 << (Parser.RANK - 65)) | (1 << (Parser.MIN - 65)) | (
7090
- 1 << (Parser.MAX - 65)) | (1 << (Parser.ABS - 65)) | (
7091
- 1 << (Parser.LN - 65)) | (1 << (Parser.LOG - 65)) | (
7092
- 1 << (Parser.TRUNC - 65)) | (1 << (Parser.ROUND - 65)) | (
7093
- 1 << (Parser.POWER - 65)) | (1 << (Parser.MOD - 65)) | (
7094
- 1 << (Parser.LEN - 65)) | (1 << (Parser.TRIM - 65)) | (
7095
- 1 << (Parser.UCASE - 65)) | (1 << (Parser.LCASE - 65)) | (
7096
- 1 << (Parser.SUBSTR - 65)) | (1 << (Parser.SUM - 65)) | (
7097
- 1 << (Parser.AVG - 65)) | (1 << (Parser.MEDIAN - 65)) | (
7098
- 1 << (Parser.COUNT - 65)) | (1 << (Parser.EXP - 65)) | (
7099
- 1 << (Parser.CHARSET_MATCH - 65)) | (1 << (Parser.NVL - 65)) | (
7100
- 1 << (Parser.LTRIM - 65)) | (1 << (Parser.RTRIM - 65)) | (
7101
- 1 << (Parser.INSTR - 65)) | (1 << (Parser.REPLACE - 65)) | (
7102
- 1 << (Parser.CEIL - 65)) | (1 << (Parser.FLOOR - 65)) | (
7103
- 1 << (Parser.SQRT - 65)) | (
7104
- 1 << (Parser.STDDEV_POP - 65)))) != 0) or (
7105
- (((_la - 129)) & ~0x3f) == 0 and ((1 << (_la - 129)) & (
7106
- (1 << (Parser.STDDEV_SAMP - 129)) | (1 << (Parser.VAR_POP - 129)) | (
7107
- 1 << (Parser.VAR_SAMP - 129)) | (1 << (Parser.FIRST_VALUE - 129)) | (
7108
- 1 << (Parser.LAST_VALUE - 129)) | (1 << (Parser.LAG - 129)) | (
7109
- 1 << (Parser.LEAD - 129)) | (
7110
- 1 << (Parser.RATIO_TO_REPORT - 129)) | (
7111
- 1 << (Parser.FILL_TIME_SERIES - 129)) | (
7112
- 1 << (Parser.FLOW_TO_STOCK - 129)) | (
7113
- 1 << (Parser.STOCK_TO_FLOW - 129)) | (
7114
- 1 << (Parser.TIMESHIFT - 129)))) != 0) or (
7115
- (((_la - 196)) & ~0x3f) == 0 and ((1 << (_la - 196)) & (
7116
- (1 << (Parser.PERIOD_INDICATOR - 196)) | (1 << (Parser.TIME_AGG - 196)) | (
7117
- 1 << (Parser.CAST - 196)) | (1 << (Parser.INTEGER_CONSTANT - 196)) | (
7118
- 1 << (Parser.NUMBER_CONSTANT - 196)) | (
7119
- 1 << (Parser.BOOLEAN_CONSTANT - 196)) | (
7120
- 1 << (Parser.STRING_CONSTANT - 196)) | (
7121
- 1 << (Parser.IDENTIFIER - 196)))) != 0):
8003
+ if (
8004
+ (
8005
+ ((_la) & ~0x3F) == 0
8006
+ and (
8007
+ (1 << _la)
8008
+ & (
8009
+ (1 << Parser.LPAREN)
8010
+ | (1 << Parser.PLUS)
8011
+ | (1 << Parser.MINUS)
8012
+ | (1 << Parser.EVAL)
8013
+ | (1 << Parser.IF)
8014
+ | (1 << Parser.CURRENT_DATE)
8015
+ | (1 << Parser.NOT)
8016
+ | (1 << Parser.BETWEEN)
8017
+ | (1 << Parser.NULL_CONSTANT)
8018
+ | (1 << Parser.ISNULL)
8019
+ )
8020
+ )
8021
+ != 0
8022
+ )
8023
+ or (
8024
+ (((_la - 65)) & ~0x3F) == 0
8025
+ and (
8026
+ (1 << (_la - 65))
8027
+ & (
8028
+ (1 << (Parser.RANK - 65))
8029
+ | (1 << (Parser.MIN - 65))
8030
+ | (1 << (Parser.MAX - 65))
8031
+ | (1 << (Parser.ABS - 65))
8032
+ | (1 << (Parser.LN - 65))
8033
+ | (1 << (Parser.LOG - 65))
8034
+ | (1 << (Parser.TRUNC - 65))
8035
+ | (1 << (Parser.ROUND - 65))
8036
+ | (1 << (Parser.POWER - 65))
8037
+ | (1 << (Parser.MOD - 65))
8038
+ | (1 << (Parser.LEN - 65))
8039
+ | (1 << (Parser.TRIM - 65))
8040
+ | (1 << (Parser.UCASE - 65))
8041
+ | (1 << (Parser.LCASE - 65))
8042
+ | (1 << (Parser.SUBSTR - 65))
8043
+ | (1 << (Parser.SUM - 65))
8044
+ | (1 << (Parser.AVG - 65))
8045
+ | (1 << (Parser.MEDIAN - 65))
8046
+ | (1 << (Parser.COUNT - 65))
8047
+ | (1 << (Parser.EXP - 65))
8048
+ | (1 << (Parser.CHARSET_MATCH - 65))
8049
+ | (1 << (Parser.NVL - 65))
8050
+ | (1 << (Parser.LTRIM - 65))
8051
+ | (1 << (Parser.RTRIM - 65))
8052
+ | (1 << (Parser.INSTR - 65))
8053
+ | (1 << (Parser.REPLACE - 65))
8054
+ | (1 << (Parser.CEIL - 65))
8055
+ | (1 << (Parser.FLOOR - 65))
8056
+ | (1 << (Parser.SQRT - 65))
8057
+ | (1 << (Parser.STDDEV_POP - 65))
8058
+ )
8059
+ )
8060
+ != 0
8061
+ )
8062
+ or (
8063
+ (((_la - 129)) & ~0x3F) == 0
8064
+ and (
8065
+ (1 << (_la - 129))
8066
+ & (
8067
+ (1 << (Parser.STDDEV_SAMP - 129))
8068
+ | (1 << (Parser.VAR_POP - 129))
8069
+ | (1 << (Parser.VAR_SAMP - 129))
8070
+ | (1 << (Parser.FIRST_VALUE - 129))
8071
+ | (1 << (Parser.LAST_VALUE - 129))
8072
+ | (1 << (Parser.LAG - 129))
8073
+ | (1 << (Parser.LEAD - 129))
8074
+ | (1 << (Parser.RATIO_TO_REPORT - 129))
8075
+ | (1 << (Parser.FILL_TIME_SERIES - 129))
8076
+ | (1 << (Parser.FLOW_TO_STOCK - 129))
8077
+ | (1 << (Parser.STOCK_TO_FLOW - 129))
8078
+ | (1 << (Parser.TIMESHIFT - 129))
8079
+ )
8080
+ )
8081
+ != 0
8082
+ )
8083
+ or (
8084
+ (((_la - 196)) & ~0x3F) == 0
8085
+ and (
8086
+ (1 << (_la - 196))
8087
+ & (
8088
+ (1 << (Parser.PERIOD_INDICATOR - 196))
8089
+ | (1 << (Parser.TIME_AGG - 196))
8090
+ | (1 << (Parser.CAST - 196))
8091
+ | (1 << (Parser.INTEGER_CONSTANT - 196))
8092
+ | (1 << (Parser.NUMBER_CONSTANT - 196))
8093
+ | (1 << (Parser.BOOLEAN_CONSTANT - 196))
8094
+ | (1 << (Parser.STRING_CONSTANT - 196))
8095
+ | (1 << (Parser.IDENTIFIER - 196))
8096
+ )
8097
+ )
8098
+ != 0
8099
+ )
8100
+ ):
7122
8101
  self.state = 869
7123
8102
  self.exprComponent(0)
7124
8103
 
@@ -7270,8 +8249,9 @@ class Parser(Parser):
7270
8249
 
7271
8250
  class SetOrSYmDiffAtomContext(SetOperatorsContext):
7272
8251
 
7273
- def __init__(self, parser,
7274
- ctx: ParserRuleContext): # actually a VtlParser.SetOperatorsContext
8252
+ def __init__(
8253
+ self, parser, ctx: ParserRuleContext
8254
+ ): # actually a VtlParser.SetOperatorsContext
7275
8255
  super().__init__(parser)
7276
8256
  self.op = None # Token
7277
8257
  self.left = None # ExprContext
@@ -7307,8 +8287,9 @@ class Parser(Parser):
7307
8287
 
7308
8288
  class IntersectAtomContext(SetOperatorsContext):
7309
8289
 
7310
- def __init__(self, parser,
7311
- ctx: ParserRuleContext): # actually a VtlParser.SetOperatorsContext
8290
+ def __init__(
8291
+ self, parser, ctx: ParserRuleContext
8292
+ ): # actually a VtlParser.SetOperatorsContext
7312
8293
  super().__init__(parser)
7313
8294
  self.left = None # ExprContext
7314
8295
  self.copyFrom(ctx)
@@ -7342,8 +8323,9 @@ class Parser(Parser):
7342
8323
 
7343
8324
  class UnionAtomContext(SetOperatorsContext):
7344
8325
 
7345
- def __init__(self, parser,
7346
- ctx: ParserRuleContext): # actually a VtlParser.SetOperatorsContext
8326
+ def __init__(
8327
+ self, parser, ctx: ParserRuleContext
8328
+ ): # actually a VtlParser.SetOperatorsContext
7347
8329
  super().__init__(parser)
7348
8330
  self.left = None # ExprContext
7349
8331
  self.copyFrom(ctx)
@@ -7559,11 +8541,17 @@ class Parser(Parser):
7559
8541
  self.state = 959
7560
8542
  self._errHandler.sync(self)
7561
8543
  _la = self._input.LA(1)
7562
- if ((((_la - 213)) & ~0x3f) == 0 and ((1 << (_la - 213)) & (
7563
- (1 << (Parser.NON_NULL - 213)) | (1 << (Parser.NON_ZERO - 213)) | (
7564
- 1 << (Parser.PARTIAL_NULL - 213)) | (1 << (Parser.PARTIAL_ZERO - 213)) | (
7565
- 1 << (Parser.ALWAYS_NULL - 213)) | (
7566
- 1 << (Parser.ALWAYS_ZERO - 213)))) != 0):
8544
+ if (((_la - 213)) & ~0x3F) == 0 and (
8545
+ (1 << (_la - 213))
8546
+ & (
8547
+ (1 << (Parser.NON_NULL - 213))
8548
+ | (1 << (Parser.NON_ZERO - 213))
8549
+ | (1 << (Parser.PARTIAL_NULL - 213))
8550
+ | (1 << (Parser.PARTIAL_ZERO - 213))
8551
+ | (1 << (Parser.ALWAYS_NULL - 213))
8552
+ | (1 << (Parser.ALWAYS_ZERO - 213))
8553
+ )
8554
+ ) != 0:
7567
8555
  self.state = 958
7568
8556
  self.validationMode()
7569
8557
 
@@ -7605,8 +8593,9 @@ class Parser(Parser):
7605
8593
 
7606
8594
  class ValidateHRrulesetContext(ValidationOperatorsContext):
7607
8595
 
7608
- def __init__(self, parser,
7609
- ctx: ParserRuleContext): # actually a VtlParser.ValidationOperatorsContext
8596
+ def __init__(
8597
+ self, parser, ctx: ParserRuleContext
8598
+ ): # actually a VtlParser.ValidationOperatorsContext
7610
8599
  super().__init__(parser)
7611
8600
  self.op = None # ExprContext
7612
8601
  self.hrName = None # Token
@@ -7656,8 +8645,9 @@ class Parser(Parser):
7656
8645
 
7657
8646
  class ValidateDPrulesetContext(ValidationOperatorsContext):
7658
8647
 
7659
- def __init__(self, parser,
7660
- ctx: ParserRuleContext): # actually a VtlParser.ValidationOperatorsContext
8648
+ def __init__(
8649
+ self, parser, ctx: ParserRuleContext
8650
+ ): # actually a VtlParser.ValidationOperatorsContext
7661
8651
  super().__init__(parser)
7662
8652
  self.op = None # ExprContext
7663
8653
  self.dpName = None # Token
@@ -7704,8 +8694,9 @@ class Parser(Parser):
7704
8694
 
7705
8695
  class ValidationSimpleContext(ValidationOperatorsContext):
7706
8696
 
7707
- def __init__(self, parser,
7708
- ctx: ParserRuleContext): # actually a VtlParser.ValidationOperatorsContext
8697
+ def __init__(
8698
+ self, parser, ctx: ParserRuleContext
8699
+ ): # actually a VtlParser.ValidationOperatorsContext
7709
8700
  super().__init__(parser)
7710
8701
  self.op = None # ExprContext
7711
8702
  self.codeErr = None # ErCodeContext
@@ -7830,11 +8821,17 @@ class Parser(Parser):
7830
8821
  self.state = 1003
7831
8822
  self._errHandler.sync(self)
7832
8823
  _la = self._input.LA(1)
7833
- if ((((_la - 213)) & ~0x3f) == 0 and ((1 << (_la - 213)) & (
7834
- (1 << (Parser.NON_NULL - 213)) | (1 << (Parser.NON_ZERO - 213)) | (
7835
- 1 << (Parser.PARTIAL_NULL - 213)) | (1 << (Parser.PARTIAL_ZERO - 213)) | (
7836
- 1 << (Parser.ALWAYS_NULL - 213)) | (
7837
- 1 << (Parser.ALWAYS_ZERO - 213)))) != 0):
8824
+ if (((_la - 213)) & ~0x3F) == 0 and (
8825
+ (1 << (_la - 213))
8826
+ & (
8827
+ (1 << (Parser.NON_NULL - 213))
8828
+ | (1 << (Parser.NON_ZERO - 213))
8829
+ | (1 << (Parser.PARTIAL_NULL - 213))
8830
+ | (1 << (Parser.PARTIAL_ZERO - 213))
8831
+ | (1 << (Parser.ALWAYS_NULL - 213))
8832
+ | (1 << (Parser.ALWAYS_ZERO - 213))
8833
+ )
8834
+ ) != 0:
7838
8835
  self.state = 1002
7839
8836
  self.validationMode()
7840
8837
 
@@ -7926,8 +8923,9 @@ class Parser(Parser):
7926
8923
 
7927
8924
  class NvlAtomContext(ConditionalOperatorsContext):
7928
8925
 
7929
- def __init__(self, parser,
7930
- ctx: ParserRuleContext): # actually a VtlParser.ConditionalOperatorsContext
8926
+ def __init__(
8927
+ self, parser, ctx: ParserRuleContext
8928
+ ): # actually a VtlParser.ConditionalOperatorsContext
7931
8929
  super().__init__(parser)
7932
8930
  self.left = None # ExprContext
7933
8931
  self.right = None # ExprContext
@@ -7998,8 +8996,9 @@ class Parser(Parser):
7998
8996
 
7999
8997
  class NvlAtomComponentContext(ConditionalOperatorsComponentContext):
8000
8998
 
8001
- def __init__(self, parser,
8002
- ctx: ParserRuleContext): # actually a VtlParser.ConditionalOperatorsComponentContext
8999
+ def __init__(
9000
+ self, parser, ctx: ParserRuleContext
9001
+ ): # actually a VtlParser.ConditionalOperatorsComponentContext
8003
9002
  super().__init__(parser)
8004
9003
  self.left = None # ExprComponentContext
8005
9004
  self.right = None # ExprComponentContext
@@ -8070,8 +9069,9 @@ class Parser(Parser):
8070
9069
 
8071
9070
  class AggrCompContext(AggrOperatorsContext):
8072
9071
 
8073
- def __init__(self, parser,
8074
- ctx: ParserRuleContext): # actually a VtlParser.AggrOperatorsContext
9072
+ def __init__(
9073
+ self, parser, ctx: ParserRuleContext
9074
+ ): # actually a VtlParser.AggrOperatorsContext
8075
9075
  super().__init__(parser)
8076
9076
  self.op = None # Token
8077
9077
  self.copyFrom(ctx)
@@ -8123,8 +9123,9 @@ class Parser(Parser):
8123
9123
 
8124
9124
  class CountAggrCompContext(AggrOperatorsContext):
8125
9125
 
8126
- def __init__(self, parser,
8127
- ctx: ParserRuleContext): # actually a VtlParser.AggrOperatorsContext
9126
+ def __init__(
9127
+ self, parser, ctx: ParserRuleContext
9128
+ ): # actually a VtlParser.AggrOperatorsContext
8128
9129
  super().__init__(parser)
8129
9130
  self.copyFrom(ctx)
8130
9131
 
@@ -8158,13 +9159,27 @@ class Parser(Parser):
8158
9159
  self.state = 1046
8159
9160
  localctx.op = self._input.LT(1)
8160
9161
  _la = self._input.LA(1)
8161
- if not (((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & (
8162
- (1 << (Parser.MIN - 68)) | (1 << (Parser.MAX - 68)) | (
8163
- 1 << (Parser.SUM - 68)) | (1 << (Parser.AVG - 68)) | (
8164
- 1 << (Parser.MEDIAN - 68)) | (1 << (Parser.COUNT - 68)) | (
8165
- 1 << (Parser.STDDEV_POP - 68)) | (
8166
- 1 << (Parser.STDDEV_SAMP - 68)) | (1 << (Parser.VAR_POP - 68)) | (
8167
- 1 << (Parser.VAR_SAMP - 68)))) != 0)):
9162
+ if not (
9163
+ (
9164
+ (((_la - 68)) & ~0x3F) == 0
9165
+ and (
9166
+ (1 << (_la - 68))
9167
+ & (
9168
+ (1 << (Parser.MIN - 68))
9169
+ | (1 << (Parser.MAX - 68))
9170
+ | (1 << (Parser.SUM - 68))
9171
+ | (1 << (Parser.AVG - 68))
9172
+ | (1 << (Parser.MEDIAN - 68))
9173
+ | (1 << (Parser.COUNT - 68))
9174
+ | (1 << (Parser.STDDEV_POP - 68))
9175
+ | (1 << (Parser.STDDEV_SAMP - 68))
9176
+ | (1 << (Parser.VAR_POP - 68))
9177
+ | (1 << (Parser.VAR_SAMP - 68))
9178
+ )
9179
+ )
9180
+ != 0
9181
+ )
9182
+ ):
8168
9183
  localctx.op = self._errHandler.recoverInline(self)
8169
9184
  else:
8170
9185
  self._errHandler.reportMatch(self)
@@ -8188,7 +9203,6 @@ class Parser(Parser):
8188
9203
  self.match(Parser.RPAREN)
8189
9204
  pass
8190
9205
 
8191
-
8192
9206
  except RecognitionException as re:
8193
9207
  localctx.exception = re
8194
9208
  self._errHandler.reportError(self, re)
@@ -8211,8 +9225,9 @@ class Parser(Parser):
8211
9225
 
8212
9226
  class AggrDatasetContext(AggrOperatorsGroupingContext):
8213
9227
 
8214
- def __init__(self, parser,
8215
- ctx: ParserRuleContext): # actually a VtlParser.AggrOperatorsGroupingContext
9228
+ def __init__(
9229
+ self, parser, ctx: ParserRuleContext
9230
+ ): # actually a VtlParser.AggrOperatorsGroupingContext
8216
9231
  super().__init__(parser)
8217
9232
  self.op = None # Token
8218
9233
  self.copyFrom(ctx)
@@ -8279,12 +9294,27 @@ class Parser(Parser):
8279
9294
  self.state = 1056
8280
9295
  localctx.op = self._input.LT(1)
8281
9296
  _la = self._input.LA(1)
8282
- if not (((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & (
8283
- (1 << (Parser.MIN - 68)) | (1 << (Parser.MAX - 68)) | (
8284
- 1 << (Parser.SUM - 68)) | (1 << (Parser.AVG - 68)) | (
8285
- 1 << (Parser.MEDIAN - 68)) | (1 << (Parser.COUNT - 68)) | (
8286
- 1 << (Parser.STDDEV_POP - 68)) | (1 << (Parser.STDDEV_SAMP - 68)) | (
8287
- 1 << (Parser.VAR_POP - 68)) | (1 << (Parser.VAR_SAMP - 68)))) != 0)):
9297
+ if not (
9298
+ (
9299
+ (((_la - 68)) & ~0x3F) == 0
9300
+ and (
9301
+ (1 << (_la - 68))
9302
+ & (
9303
+ (1 << (Parser.MIN - 68))
9304
+ | (1 << (Parser.MAX - 68))
9305
+ | (1 << (Parser.SUM - 68))
9306
+ | (1 << (Parser.AVG - 68))
9307
+ | (1 << (Parser.MEDIAN - 68))
9308
+ | (1 << (Parser.COUNT - 68))
9309
+ | (1 << (Parser.STDDEV_POP - 68))
9310
+ | (1 << (Parser.STDDEV_SAMP - 68))
9311
+ | (1 << (Parser.VAR_POP - 68))
9312
+ | (1 << (Parser.VAR_SAMP - 68))
9313
+ )
9314
+ )
9315
+ != 0
9316
+ )
9317
+ ):
8288
9318
  localctx.op = self._errHandler.recoverInline(self)
8289
9319
  else:
8290
9320
  self._errHandler.reportMatch(self)
@@ -8330,8 +9360,9 @@ class Parser(Parser):
8330
9360
 
8331
9361
  class LagOrLeadAnContext(AnFunctionContext):
8332
9362
 
8333
- def __init__(self, parser,
8334
- ctx: ParserRuleContext): # actually a VtlParser.AnFunctionContext
9363
+ def __init__(
9364
+ self, parser, ctx: ParserRuleContext
9365
+ ): # actually a VtlParser.AnFunctionContext
8335
9366
  super().__init__(parser)
8336
9367
  self.op = None # Token
8337
9368
  self.offet = None # SignedIntegerContext
@@ -8390,8 +9421,9 @@ class Parser(Parser):
8390
9421
 
8391
9422
  class RatioToReportAnContext(AnFunctionContext):
8392
9423
 
8393
- def __init__(self, parser,
8394
- ctx: ParserRuleContext): # actually a VtlParser.AnFunctionContext
9424
+ def __init__(
9425
+ self, parser, ctx: ParserRuleContext
9426
+ ): # actually a VtlParser.AnFunctionContext
8395
9427
  super().__init__(parser)
8396
9428
  self.op = None # Token
8397
9429
  self.partition = None # PartitionByClauseContext
@@ -8429,8 +9461,9 @@ class Parser(Parser):
8429
9461
 
8430
9462
  class AnSimpleFunctionContext(AnFunctionContext):
8431
9463
 
8432
- def __init__(self, parser,
8433
- ctx: ParserRuleContext): # actually a VtlParser.AnFunctionContext
9464
+ def __init__(
9465
+ self, parser, ctx: ParserRuleContext
9466
+ ): # actually a VtlParser.AnFunctionContext
8434
9467
  super().__init__(parser)
8435
9468
  self.op = None # Token
8436
9469
  self.partition = None # PartitionByClauseContext
@@ -8516,22 +9549,48 @@ class Parser(Parser):
8516
9549
  self.state = 1114
8517
9550
  self._errHandler.sync(self)
8518
9551
  token = self._input.LA(1)
8519
- if token in [Parser.MIN, Parser.MAX, Parser.SUM, Parser.AVG, Parser.MEDIAN,
8520
- Parser.COUNT, Parser.STDDEV_POP, Parser.STDDEV_SAMP, Parser.VAR_POP,
8521
- Parser.VAR_SAMP, Parser.FIRST_VALUE, Parser.LAST_VALUE]:
9552
+ if token in [
9553
+ Parser.MIN,
9554
+ Parser.MAX,
9555
+ Parser.SUM,
9556
+ Parser.AVG,
9557
+ Parser.MEDIAN,
9558
+ Parser.COUNT,
9559
+ Parser.STDDEV_POP,
9560
+ Parser.STDDEV_SAMP,
9561
+ Parser.VAR_POP,
9562
+ Parser.VAR_SAMP,
9563
+ Parser.FIRST_VALUE,
9564
+ Parser.LAST_VALUE,
9565
+ ]:
8522
9566
  localctx = Parser.AnSimpleFunctionContext(self, localctx)
8523
9567
  self.enterOuterAlt(localctx, 1)
8524
9568
  self.state = 1067
8525
9569
  localctx.op = self._input.LT(1)
8526
9570
  _la = self._input.LA(1)
8527
- if not (((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & (
8528
- (1 << (Parser.MIN - 68)) | (1 << (Parser.MAX - 68)) | (
8529
- 1 << (Parser.SUM - 68)) | (1 << (Parser.AVG - 68)) | (
8530
- 1 << (Parser.MEDIAN - 68)) | (1 << (Parser.COUNT - 68)) | (
8531
- 1 << (Parser.STDDEV_POP - 68)) | (
8532
- 1 << (Parser.STDDEV_SAMP - 68)) | (1 << (Parser.VAR_POP - 68)) | (
8533
- 1 << (
8534
- Parser.VAR_SAMP - 68)))) != 0) or _la == Parser.FIRST_VALUE or _la == Parser.LAST_VALUE):
9571
+ if not (
9572
+ (
9573
+ (((_la - 68)) & ~0x3F) == 0
9574
+ and (
9575
+ (1 << (_la - 68))
9576
+ & (
9577
+ (1 << (Parser.MIN - 68))
9578
+ | (1 << (Parser.MAX - 68))
9579
+ | (1 << (Parser.SUM - 68))
9580
+ | (1 << (Parser.AVG - 68))
9581
+ | (1 << (Parser.MEDIAN - 68))
9582
+ | (1 << (Parser.COUNT - 68))
9583
+ | (1 << (Parser.STDDEV_POP - 68))
9584
+ | (1 << (Parser.STDDEV_SAMP - 68))
9585
+ | (1 << (Parser.VAR_POP - 68))
9586
+ | (1 << (Parser.VAR_SAMP - 68))
9587
+ )
9588
+ )
9589
+ != 0
9590
+ )
9591
+ or _la == Parser.FIRST_VALUE
9592
+ or _la == Parser.LAST_VALUE
9593
+ ):
8535
9594
  localctx.op = self._errHandler.recoverInline(self)
8536
9595
  else:
8537
9596
  self._errHandler.reportMatch(self)
@@ -8668,8 +9727,9 @@ class Parser(Parser):
8668
9727
 
8669
9728
  class AnSimpleFunctionComponentContext(AnFunctionComponentContext):
8670
9729
 
8671
- def __init__(self, parser,
8672
- ctx: ParserRuleContext): # actually a VtlParser.AnFunctionComponentContext
9730
+ def __init__(
9731
+ self, parser, ctx: ParserRuleContext
9732
+ ): # actually a VtlParser.AnFunctionComponentContext
8673
9733
  super().__init__(parser)
8674
9734
  self.op = None # Token
8675
9735
  self.partition = None # PartitionByClauseContext
@@ -8748,8 +9808,9 @@ class Parser(Parser):
8748
9808
 
8749
9809
  class LagOrLeadAnComponentContext(AnFunctionComponentContext):
8750
9810
 
8751
- def __init__(self, parser,
8752
- ctx: ParserRuleContext): # actually a VtlParser.AnFunctionComponentContext
9811
+ def __init__(
9812
+ self, parser, ctx: ParserRuleContext
9813
+ ): # actually a VtlParser.AnFunctionComponentContext
8753
9814
  super().__init__(parser)
8754
9815
  self.op = None # Token
8755
9816
  self.offet = None # SignedIntegerContext
@@ -8805,8 +9866,9 @@ class Parser(Parser):
8805
9866
 
8806
9867
  class RankAnComponentContext(AnFunctionComponentContext):
8807
9868
 
8808
- def __init__(self, parser,
8809
- ctx: ParserRuleContext): # actually a VtlParser.AnFunctionComponentContext
9869
+ def __init__(
9870
+ self, parser, ctx: ParserRuleContext
9871
+ ): # actually a VtlParser.AnFunctionComponentContext
8810
9872
  super().__init__(parser)
8811
9873
  self.op = None # Token
8812
9874
  self.partition = None # PartitionByClauseContext
@@ -8845,8 +9907,9 @@ class Parser(Parser):
8845
9907
 
8846
9908
  class RatioToReportAnComponentContext(AnFunctionComponentContext):
8847
9909
 
8848
- def __init__(self, parser,
8849
- ctx: ParserRuleContext): # actually a VtlParser.AnFunctionComponentContext
9910
+ def __init__(
9911
+ self, parser, ctx: ParserRuleContext
9912
+ ): # actually a VtlParser.AnFunctionComponentContext
8850
9913
  super().__init__(parser)
8851
9914
  self.op = None # Token
8852
9915
  self.partition = None # PartitionByClauseContext
@@ -8891,22 +9954,48 @@ class Parser(Parser):
8891
9954
  self.state = 1174
8892
9955
  self._errHandler.sync(self)
8893
9956
  token = self._input.LA(1)
8894
- if token in [Parser.MIN, Parser.MAX, Parser.SUM, Parser.AVG, Parser.MEDIAN,
8895
- Parser.COUNT, Parser.STDDEV_POP, Parser.STDDEV_SAMP, Parser.VAR_POP,
8896
- Parser.VAR_SAMP, Parser.FIRST_VALUE, Parser.LAST_VALUE]:
9957
+ if token in [
9958
+ Parser.MIN,
9959
+ Parser.MAX,
9960
+ Parser.SUM,
9961
+ Parser.AVG,
9962
+ Parser.MEDIAN,
9963
+ Parser.COUNT,
9964
+ Parser.STDDEV_POP,
9965
+ Parser.STDDEV_SAMP,
9966
+ Parser.VAR_POP,
9967
+ Parser.VAR_SAMP,
9968
+ Parser.FIRST_VALUE,
9969
+ Parser.LAST_VALUE,
9970
+ ]:
8897
9971
  localctx = Parser.AnSimpleFunctionComponentContext(self, localctx)
8898
9972
  self.enterOuterAlt(localctx, 1)
8899
9973
  self.state = 1116
8900
9974
  localctx.op = self._input.LT(1)
8901
9975
  _la = self._input.LA(1)
8902
- if not (((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & (
8903
- (1 << (Parser.MIN - 68)) | (1 << (Parser.MAX - 68)) | (
8904
- 1 << (Parser.SUM - 68)) | (1 << (Parser.AVG - 68)) | (
8905
- 1 << (Parser.MEDIAN - 68)) | (1 << (Parser.COUNT - 68)) | (
8906
- 1 << (Parser.STDDEV_POP - 68)) | (
8907
- 1 << (Parser.STDDEV_SAMP - 68)) | (1 << (Parser.VAR_POP - 68)) | (
8908
- 1 << (
8909
- Parser.VAR_SAMP - 68)))) != 0) or _la == Parser.FIRST_VALUE or _la == Parser.LAST_VALUE):
9976
+ if not (
9977
+ (
9978
+ (((_la - 68)) & ~0x3F) == 0
9979
+ and (
9980
+ (1 << (_la - 68))
9981
+ & (
9982
+ (1 << (Parser.MIN - 68))
9983
+ | (1 << (Parser.MAX - 68))
9984
+ | (1 << (Parser.SUM - 68))
9985
+ | (1 << (Parser.AVG - 68))
9986
+ | (1 << (Parser.MEDIAN - 68))
9987
+ | (1 << (Parser.COUNT - 68))
9988
+ | (1 << (Parser.STDDEV_POP - 68))
9989
+ | (1 << (Parser.STDDEV_SAMP - 68))
9990
+ | (1 << (Parser.VAR_POP - 68))
9991
+ | (1 << (Parser.VAR_SAMP - 68))
9992
+ )
9993
+ )
9994
+ != 0
9995
+ )
9996
+ or _la == Parser.FIRST_VALUE
9997
+ or _la == Parser.LAST_VALUE
9998
+ ):
8910
9999
  localctx.op = self._errHandler.recoverInline(self)
8911
10000
  else:
8912
10001
  self._errHandler.reportMatch(self)
@@ -8972,12 +10061,20 @@ class Parser(Parser):
8972
10061
  self.state = 1139
8973
10062
  self._errHandler.sync(self)
8974
10063
  _la = self._input.LA(1)
8975
- if _la == Parser.NULL_CONSTANT or ((((_la - 206)) & ~0x3f) == 0 and (
8976
- (1 << (_la - 206)) & (
8977
- (1 << (Parser.CAST - 206)) | (1 << (Parser.INTEGER_CONSTANT - 206)) | (
8978
- 1 << (Parser.NUMBER_CONSTANT - 206)) | (
8979
- 1 << (Parser.BOOLEAN_CONSTANT - 206)) | (
8980
- 1 << (Parser.STRING_CONSTANT - 206)))) != 0):
10064
+ if _la == Parser.NULL_CONSTANT or (
10065
+ (((_la - 206)) & ~0x3F) == 0
10066
+ and (
10067
+ (1 << (_la - 206))
10068
+ & (
10069
+ (1 << (Parser.CAST - 206))
10070
+ | (1 << (Parser.INTEGER_CONSTANT - 206))
10071
+ | (1 << (Parser.NUMBER_CONSTANT - 206))
10072
+ | (1 << (Parser.BOOLEAN_CONSTANT - 206))
10073
+ | (1 << (Parser.STRING_CONSTANT - 206))
10074
+ )
10075
+ )
10076
+ != 0
10077
+ ):
8981
10078
  self.state = 1138
8982
10079
  localctx.defaultValue = self.scalarItem()
8983
10080
 
@@ -9197,10 +10294,19 @@ class Parser(Parser):
9197
10294
  self.state = 1189
9198
10295
  self._errHandler.sync(self)
9199
10296
  _la = self._input.LA(1)
9200
- if ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & (
9201
- (1 << (Parser.DIMENSION - 91)) | (1 << (Parser.MEASURE - 91)) | (
9202
- 1 << (Parser.ATTRIBUTE - 91)) | (
9203
- 1 << (Parser.VIRAL - 91)))) != 0) or _la == Parser.COMPONENT:
10297
+ if (
10298
+ (((_la - 91)) & ~0x3F) == 0
10299
+ and (
10300
+ (1 << (_la - 91))
10301
+ & (
10302
+ (1 << (Parser.DIMENSION - 91))
10303
+ | (1 << (Parser.MEASURE - 91))
10304
+ | (1 << (Parser.ATTRIBUTE - 91))
10305
+ | (1 << (Parser.VIRAL - 91))
10306
+ )
10307
+ )
10308
+ != 0
10309
+ ) or _la == Parser.COMPONENT:
9204
10310
  self.state = 1188
9205
10311
  self.componentRole()
9206
10312
 
@@ -9255,10 +10361,19 @@ class Parser(Parser):
9255
10361
  self.state = 1196
9256
10362
  self._errHandler.sync(self)
9257
10363
  _la = self._input.LA(1)
9258
- if ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & (
9259
- (1 << (Parser.DIMENSION - 91)) | (1 << (Parser.MEASURE - 91)) | (
9260
- 1 << (Parser.ATTRIBUTE - 91)) | (
9261
- 1 << (Parser.VIRAL - 91)))) != 0) or _la == Parser.COMPONENT:
10364
+ if (
10365
+ (((_la - 91)) & ~0x3F) == 0
10366
+ and (
10367
+ (1 << (_la - 91))
10368
+ & (
10369
+ (1 << (Parser.DIMENSION - 91))
10370
+ | (1 << (Parser.MEASURE - 91))
10371
+ | (1 << (Parser.ATTRIBUTE - 91))
10372
+ | (1 << (Parser.VIRAL - 91))
10373
+ )
10374
+ )
10375
+ != 0
10376
+ ) or _la == Parser.COMPONENT:
9262
10377
  self.state = 1195
9263
10378
  self.componentRole()
9264
10379
 
@@ -9334,8 +10449,9 @@ class Parser(Parser):
9334
10449
 
9335
10450
  class ScalarWithCastContext(ScalarItemContext):
9336
10451
 
9337
- def __init__(self, parser,
9338
- ctx: ParserRuleContext): # actually a VtlParser.ScalarItemContext
10452
+ def __init__(
10453
+ self, parser, ctx: ParserRuleContext
10454
+ ): # actually a VtlParser.ScalarItemContext
9339
10455
  super().__init__(parser)
9340
10456
  self.copyFrom(ctx)
9341
10457
 
@@ -9371,8 +10487,9 @@ class Parser(Parser):
9371
10487
 
9372
10488
  class SimpleScalarContext(ScalarItemContext):
9373
10489
 
9374
- def __init__(self, parser,
9375
- ctx: ParserRuleContext): # actually a VtlParser.ScalarItemContext
10490
+ def __init__(
10491
+ self, parser, ctx: ParserRuleContext
10492
+ ): # actually a VtlParser.ScalarItemContext
9376
10493
  super().__init__(parser)
9377
10494
  self.copyFrom(ctx)
9378
10495
 
@@ -9394,8 +10511,13 @@ class Parser(Parser):
9394
10511
  self.state = 1218
9395
10512
  self._errHandler.sync(self)
9396
10513
  token = self._input.LA(1)
9397
- if token in [Parser.NULL_CONSTANT, Parser.INTEGER_CONSTANT, Parser.NUMBER_CONSTANT,
9398
- Parser.BOOLEAN_CONSTANT, Parser.STRING_CONSTANT]:
10514
+ if token in [
10515
+ Parser.NULL_CONSTANT,
10516
+ Parser.INTEGER_CONSTANT,
10517
+ Parser.NUMBER_CONSTANT,
10518
+ Parser.BOOLEAN_CONSTANT,
10519
+ Parser.STRING_CONSTANT,
10520
+ ]:
9399
10521
  localctx = Parser.SimpleScalarContext(self, localctx)
9400
10522
  self.enterOuterAlt(localctx, 1)
9401
10523
  self.state = 1206
@@ -9571,8 +10693,6 @@ class Parser(Parser):
9571
10693
  self._errHandler.sync(self)
9572
10694
  _la = self._input.LA(1)
9573
10695
 
9574
-
9575
-
9576
10696
  except RecognitionException as re:
9577
10697
  localctx.exception = re
9578
10698
  self._errHandler.reportError(self, re)
@@ -9623,7 +10743,6 @@ class Parser(Parser):
9623
10743
  self.state = 1249
9624
10744
  self.alias()
9625
10745
 
9626
-
9627
10746
  except RecognitionException as re:
9628
10747
  localctx.exception = re
9629
10748
  self._errHandler.reportError(self, re)
@@ -9712,7 +10831,6 @@ class Parser(Parser):
9712
10831
  self.state = 1263
9713
10832
  self.renameClause()
9714
10833
 
9715
-
9716
10834
  except RecognitionException as re:
9717
10835
  localctx.exception = re
9718
10836
  self._errHandler.reportError(self, re)
@@ -9937,7 +11055,6 @@ class Parser(Parser):
9937
11055
  self._errHandler.reportMatch(self)
9938
11056
  self.consume()
9939
11057
 
9940
-
9941
11058
  except RecognitionException as re:
9942
11059
  localctx.exception = re
9943
11060
  self._errHandler.reportError(self, re)
@@ -10142,7 +11259,6 @@ class Parser(Parser):
10142
11259
  self.match(Parser.FOLLOWING)
10143
11260
  pass
10144
11261
 
10145
-
10146
11262
  except RecognitionException as re:
10147
11263
  localctx.exception = re
10148
11264
  self._errHandler.reportError(self, re)
@@ -10165,8 +11281,9 @@ class Parser(Parser):
10165
11281
 
10166
11282
  class GroupAllContext(GroupingClauseContext):
10167
11283
 
10168
- def __init__(self, parser,
10169
- ctx: ParserRuleContext): # actually a VtlParser.GroupingClauseContext
11284
+ def __init__(
11285
+ self, parser, ctx: ParserRuleContext
11286
+ ): # actually a VtlParser.GroupingClauseContext
10170
11287
  super().__init__(parser)
10171
11288
  self.copyFrom(ctx)
10172
11289
 
@@ -10187,8 +11304,9 @@ class Parser(Parser):
10187
11304
 
10188
11305
  class GroupByOrExceptContext(GroupingClauseContext):
10189
11306
 
10190
- def __init__(self, parser,
10191
- ctx: ParserRuleContext): # actually a VtlParser.GroupingClauseContext
11307
+ def __init__(
11308
+ self, parser, ctx: ParserRuleContext
11309
+ ): # actually a VtlParser.GroupingClauseContext
10192
11310
  super().__init__(parser)
10193
11311
  self.op = None # Token
10194
11312
  self.copyFrom(ctx)
@@ -10269,7 +11387,6 @@ class Parser(Parser):
10269
11387
  self.exprComponent(0)
10270
11388
  pass
10271
11389
 
10272
-
10273
11390
  except RecognitionException as re:
10274
11391
  localctx.exception = re
10275
11392
  self._errHandler.reportError(self, re)
@@ -10364,7 +11481,6 @@ class Parser(Parser):
10364
11481
  self.state = 1339
10365
11482
  self.scalarItem()
10366
11483
 
10367
-
10368
11484
  except RecognitionException as re:
10369
11485
  localctx.exception = re
10370
11486
  self._errHandler.reportError(self, re)
@@ -10405,9 +11521,18 @@ class Parser(Parser):
10405
11521
  self.state = 1345
10406
11522
  self._errHandler.sync(self)
10407
11523
  token = self._input.LA(1)
10408
- if token in [Parser.BOOLEAN, Parser.DATE, Parser.TIME_PERIOD, Parser.NUMBER,
10409
- Parser.STRING, Parser.TIME, Parser.INTEGER, Parser.DURATION, Parser.SCALAR,
10410
- Parser.IDENTIFIER]:
11524
+ if token in [
11525
+ Parser.BOOLEAN,
11526
+ Parser.DATE,
11527
+ Parser.TIME_PERIOD,
11528
+ Parser.NUMBER,
11529
+ Parser.STRING,
11530
+ Parser.TIME,
11531
+ Parser.INTEGER,
11532
+ Parser.DURATION,
11533
+ Parser.SCALAR,
11534
+ Parser.IDENTIFIER,
11535
+ ]:
10411
11536
  self.enterOuterAlt(localctx, 1)
10412
11537
  self.state = 1342
10413
11538
  self.scalarType()
@@ -10417,8 +11542,13 @@ class Parser(Parser):
10417
11542
  self.state = 1343
10418
11543
  self.datasetType()
10419
11544
  pass
10420
- elif token in [Parser.DIMENSION, Parser.MEASURE, Parser.ATTRIBUTE, Parser.VIRAL,
10421
- Parser.COMPONENT]:
11545
+ elif token in [
11546
+ Parser.DIMENSION,
11547
+ Parser.MEASURE,
11548
+ Parser.ATTRIBUTE,
11549
+ Parser.VIRAL,
11550
+ Parser.COMPONENT,
11551
+ ]:
10422
11552
  self.enterOuterAlt(localctx, 3)
10423
11553
  self.state = 1344
10424
11554
  self.componentType()
@@ -10463,15 +11593,29 @@ class Parser(Parser):
10463
11593
  self.state = 1349
10464
11594
  self._errHandler.sync(self)
10465
11595
  token = self._input.LA(1)
10466
- if token in [Parser.DIMENSION, Parser.MEASURE, Parser.ATTRIBUTE, Parser.VIRAL,
10467
- Parser.COMPONENT]:
11596
+ if token in [
11597
+ Parser.DIMENSION,
11598
+ Parser.MEASURE,
11599
+ Parser.ATTRIBUTE,
11600
+ Parser.VIRAL,
11601
+ Parser.COMPONENT,
11602
+ ]:
10468
11603
  self.enterOuterAlt(localctx, 1)
10469
11604
  self.state = 1347
10470
11605
  self.componentType()
10471
11606
  pass
10472
- elif token in [Parser.BOOLEAN, Parser.DATE, Parser.TIME_PERIOD, Parser.NUMBER,
10473
- Parser.STRING, Parser.TIME, Parser.INTEGER, Parser.DURATION,
10474
- Parser.SCALAR, Parser.IDENTIFIER]:
11607
+ elif token in [
11608
+ Parser.BOOLEAN,
11609
+ Parser.DATE,
11610
+ Parser.TIME_PERIOD,
11611
+ Parser.NUMBER,
11612
+ Parser.STRING,
11613
+ Parser.TIME,
11614
+ Parser.INTEGER,
11615
+ Parser.DURATION,
11616
+ Parser.SCALAR,
11617
+ Parser.IDENTIFIER,
11618
+ ]:
10475
11619
  self.enterOuterAlt(localctx, 2)
10476
11620
  self.state = 1348
10477
11621
  self.scalarType()
@@ -10525,9 +11669,18 @@ class Parser(Parser):
10525
11669
  self.state = 1356
10526
11670
  self._errHandler.sync(self)
10527
11671
  token = self._input.LA(1)
10528
- if token in [Parser.BOOLEAN, Parser.DATE, Parser.TIME_PERIOD, Parser.NUMBER,
10529
- Parser.STRING, Parser.TIME, Parser.INTEGER, Parser.DURATION, Parser.SCALAR,
10530
- Parser.IDENTIFIER]:
11672
+ if token in [
11673
+ Parser.BOOLEAN,
11674
+ Parser.DATE,
11675
+ Parser.TIME_PERIOD,
11676
+ Parser.NUMBER,
11677
+ Parser.STRING,
11678
+ Parser.TIME,
11679
+ Parser.INTEGER,
11680
+ Parser.DURATION,
11681
+ Parser.SCALAR,
11682
+ Parser.IDENTIFIER,
11683
+ ]:
10531
11684
  self.enterOuterAlt(localctx, 1)
10532
11685
  self.state = 1351
10533
11686
  self.scalarType()
@@ -10542,15 +11695,26 @@ class Parser(Parser):
10542
11695
  self.state = 1353
10543
11696
  self.scalarSetType()
10544
11697
  pass
10545
- elif token in [Parser.DATAPOINT, Parser.HIERARCHICAL, Parser.RULESET,
10546
- Parser.DATAPOINT_ON_VD, Parser.DATAPOINT_ON_VAR,
10547
- Parser.HIERARCHICAL_ON_VD, Parser.HIERARCHICAL_ON_VAR]:
11698
+ elif token in [
11699
+ Parser.DATAPOINT,
11700
+ Parser.HIERARCHICAL,
11701
+ Parser.RULESET,
11702
+ Parser.DATAPOINT_ON_VD,
11703
+ Parser.DATAPOINT_ON_VAR,
11704
+ Parser.HIERARCHICAL_ON_VD,
11705
+ Parser.HIERARCHICAL_ON_VAR,
11706
+ ]:
10548
11707
  self.enterOuterAlt(localctx, 4)
10549
11708
  self.state = 1354
10550
11709
  self.rulesetType()
10551
11710
  pass
10552
- elif token in [Parser.DIMENSION, Parser.MEASURE, Parser.ATTRIBUTE, Parser.VIRAL,
10553
- Parser.COMPONENT]:
11711
+ elif token in [
11712
+ Parser.DIMENSION,
11713
+ Parser.MEASURE,
11714
+ Parser.ATTRIBUTE,
11715
+ Parser.VIRAL,
11716
+ Parser.COMPONENT,
11717
+ ]:
10554
11718
  self.enterOuterAlt(localctx, 5)
10555
11719
  self.state = 1355
10556
11720
  self.componentType()
@@ -10608,8 +11772,11 @@ class Parser(Parser):
10608
11772
  self.state = 1359
10609
11773
  self.dpRuleset()
10610
11774
  pass
10611
- elif token in [Parser.HIERARCHICAL, Parser.HIERARCHICAL_ON_VD,
10612
- Parser.HIERARCHICAL_ON_VAR]:
11775
+ elif token in [
11776
+ Parser.HIERARCHICAL,
11777
+ Parser.HIERARCHICAL_ON_VD,
11778
+ Parser.HIERARCHICAL_ON_VAR,
11779
+ ]:
10613
11780
  self.enterOuterAlt(localctx, 3)
10614
11781
  self.state = 1360
10615
11782
  self.hrRuleset()
@@ -10665,9 +11832,17 @@ class Parser(Parser):
10665
11832
  self.state = 1365
10666
11833
  self._errHandler.sync(self)
10667
11834
  token = self._input.LA(1)
10668
- if token in [Parser.BOOLEAN, Parser.DATE, Parser.TIME_PERIOD, Parser.NUMBER,
10669
- Parser.STRING, Parser.TIME, Parser.INTEGER, Parser.DURATION,
10670
- Parser.SCALAR]:
11835
+ if token in [
11836
+ Parser.BOOLEAN,
11837
+ Parser.DATE,
11838
+ Parser.TIME_PERIOD,
11839
+ Parser.NUMBER,
11840
+ Parser.STRING,
11841
+ Parser.TIME,
11842
+ Parser.INTEGER,
11843
+ Parser.DURATION,
11844
+ Parser.SCALAR,
11845
+ ]:
10671
11846
  self.state = 1363
10672
11847
  self.basicScalarType()
10673
11848
  pass
@@ -10699,7 +11874,6 @@ class Parser(Parser):
10699
11874
  self.state = 1373
10700
11875
  self.match(Parser.NULL_CONSTANT)
10701
11876
 
10702
-
10703
11877
  except RecognitionException as re:
10704
11878
  localctx.exception = re
10705
11879
  self._errHandler.reportError(self, re)
@@ -10755,7 +11929,6 @@ class Parser(Parser):
10755
11929
  self.state = 1379
10756
11930
  self.match(Parser.MT)
10757
11931
 
10758
-
10759
11932
  except RecognitionException as re:
10760
11933
  localctx.exception = re
10761
11934
  self._errHandler.reportError(self, re)
@@ -10832,7 +12005,6 @@ class Parser(Parser):
10832
12005
  self.state = 1393
10833
12006
  self.match(Parser.GRPAREN)
10834
12007
 
10835
-
10836
12008
  except RecognitionException as re:
10837
12009
  localctx.exception = re
10838
12010
  self._errHandler.reportError(self, re)
@@ -10875,9 +12047,18 @@ class Parser(Parser):
10875
12047
  self.state = 1397
10876
12048
  self.datasetType()
10877
12049
  pass
10878
- elif token in [Parser.BOOLEAN, Parser.DATE, Parser.TIME_PERIOD, Parser.NUMBER,
10879
- Parser.STRING, Parser.TIME, Parser.INTEGER, Parser.DURATION,
10880
- Parser.SCALAR, Parser.IDENTIFIER]:
12050
+ elif token in [
12051
+ Parser.BOOLEAN,
12052
+ Parser.DATE,
12053
+ Parser.TIME_PERIOD,
12054
+ Parser.NUMBER,
12055
+ Parser.STRING,
12056
+ Parser.TIME,
12057
+ Parser.INTEGER,
12058
+ Parser.DURATION,
12059
+ Parser.SCALAR,
12060
+ Parser.IDENTIFIER,
12061
+ ]:
10881
12062
  self.enterOuterAlt(localctx, 2)
10882
12063
  self.state = 1398
10883
12064
  self.scalarType()
@@ -10940,7 +12121,6 @@ class Parser(Parser):
10940
12121
  self.state = 1404
10941
12122
  self.match(Parser.MT)
10942
12123
 
10943
-
10944
12124
  except RecognitionException as re:
10945
12125
  localctx.exception = re
10946
12126
  self._errHandler.reportError(self, re)
@@ -11521,7 +12701,6 @@ class Parser(Parser):
11521
12701
  self.state = 1496
11522
12702
  self.alias()
11523
12703
 
11524
-
11525
12704
  except RecognitionException as re:
11526
12705
  localctx.exception = re
11527
12706
  self._errHandler.reportError(self, re)
@@ -11671,7 +12850,6 @@ class Parser(Parser):
11671
12850
  self.state = 1521
11672
12851
  self.erLevel()
11673
12852
 
11674
-
11675
12853
  except RecognitionException as re:
11676
12854
  localctx.exception = re
11677
12855
  self._errHandler.reportError(self, re)
@@ -11799,7 +12977,6 @@ class Parser(Parser):
11799
12977
  self.state = 1540
11800
12978
  self.erLevel()
11801
12979
 
11802
-
11803
12980
  except RecognitionException as re:
11804
12981
  localctx.exception = re
11805
12982
  self._errHandler.reportError(self, re)
@@ -11992,9 +13169,17 @@ class Parser(Parser):
11992
13169
  self.state = 1567
11993
13170
  self._errHandler.sync(self)
11994
13171
  _la = self._input.LA(1)
11995
- if (((_la) & ~0x3f) == 0 and ((1 << _la) & (
11996
- (1 << Parser.EQ) | (1 << Parser.LT) | (1 << Parser.MT) | (1 << Parser.ME) | (
11997
- 1 << Parser.NEQ) | (1 << Parser.LE))) != 0):
13172
+ if ((_la) & ~0x3F) == 0 and (
13173
+ (1 << _la)
13174
+ & (
13175
+ (1 << Parser.EQ)
13176
+ | (1 << Parser.LT)
13177
+ | (1 << Parser.MT)
13178
+ | (1 << Parser.ME)
13179
+ | (1 << Parser.NEQ)
13180
+ | (1 << Parser.LE)
13181
+ )
13182
+ ) != 0:
11998
13183
  self.state = 1566
11999
13184
  self.comparisonOperand()
12000
13185
 
@@ -12003,9 +13188,22 @@ class Parser(Parser):
12003
13188
  self.state = 1573
12004
13189
  self._errHandler.sync(self)
12005
13190
  _la = self._input.LA(1)
12006
- while _la == Parser.PLUS or _la == Parser.MINUS or ((((_la - 229)) & ~0x3f) == 0 and (
12007
- (1 << (_la - 229)) & ((1 << (Parser.INTEGER_CONSTANT - 229)) | (
12008
- 1 << (Parser.NUMBER_CONSTANT - 229)) | (1 << (Parser.IDENTIFIER - 229)))) != 0):
13191
+ while (
13192
+ _la == Parser.PLUS
13193
+ or _la == Parser.MINUS
13194
+ or (
13195
+ (((_la - 229)) & ~0x3F) == 0
13196
+ and (
13197
+ (1 << (_la - 229))
13198
+ & (
13199
+ (1 << (Parser.INTEGER_CONSTANT - 229))
13200
+ | (1 << (Parser.NUMBER_CONSTANT - 229))
13201
+ | (1 << (Parser.IDENTIFIER - 229))
13202
+ )
13203
+ )
13204
+ != 0
13205
+ )
13206
+ ):
12009
13207
  self.state = 1570
12010
13208
  self.codeItemRelationClause()
12011
13209
  self.state = 1575
@@ -12089,7 +13287,6 @@ class Parser(Parser):
12089
13287
  self.state = 1582
12090
13288
  self.match(Parser.QRPAREN)
12091
13289
 
12092
-
12093
13290
  except RecognitionException as re:
12094
13291
  localctx.exception = re
12095
13292
  self._errHandler.reportError(self, re)
@@ -12131,10 +13328,20 @@ class Parser(Parser):
12131
13328
  self.enterOuterAlt(localctx, 1)
12132
13329
  self.state = 1586
12133
13330
  _la = self._input.LA(1)
12134
- if not (((((_la - 229)) & ~0x3f) == 0 and ((1 << (_la - 229)) & (
12135
- (1 << (Parser.INTEGER_CONSTANT - 229)) | (
12136
- 1 << (Parser.NUMBER_CONSTANT - 229)) | (
12137
- 1 << (Parser.IDENTIFIER - 229)))) != 0)):
13331
+ if not (
13332
+ (
13333
+ (((_la - 229)) & ~0x3F) == 0
13334
+ and (
13335
+ (1 << (_la - 229))
13336
+ & (
13337
+ (1 << (Parser.INTEGER_CONSTANT - 229))
13338
+ | (1 << (Parser.NUMBER_CONSTANT - 229))
13339
+ | (1 << (Parser.IDENTIFIER - 229))
13340
+ )
13341
+ )
13342
+ != 0
13343
+ )
13344
+ ):
12138
13345
  self._errHandler.recoverInline(self)
12139
13346
  else:
12140
13347
  self._errHandler.reportMatch(self)
@@ -12161,8 +13368,9 @@ class Parser(Parser):
12161
13368
 
12162
13369
  class RangeConstraintContext(ScalarTypeConstraintContext):
12163
13370
 
12164
- def __init__(self, parser,
12165
- ctx: ParserRuleContext): # actually a VtlParser.ScalarTypeConstraintContext
13371
+ def __init__(
13372
+ self, parser, ctx: ParserRuleContext
13373
+ ): # actually a VtlParser.ScalarTypeConstraintContext
12166
13374
  super().__init__(parser)
12167
13375
  self.copyFrom(ctx)
12168
13376
 
@@ -12192,8 +13400,9 @@ class Parser(Parser):
12192
13400
 
12193
13401
  class ConditionConstraintContext(ScalarTypeConstraintContext):
12194
13402
 
12195
- def __init__(self, parser,
12196
- ctx: ParserRuleContext): # actually a VtlParser.ScalarTypeConstraintContext
13403
+ def __init__(
13404
+ self, parser, ctx: ParserRuleContext
13405
+ ): # actually a VtlParser.ScalarTypeConstraintContext
12197
13406
  super().__init__(parser)
12198
13407
  self.copyFrom(ctx)
12199
13408
 
@@ -12363,7 +13572,6 @@ class Parser(Parser):
12363
13572
  self._errHandler.reportMatch(self)
12364
13573
  self.consume()
12365
13574
 
12366
-
12367
13575
  except RecognitionException as re:
12368
13576
  localctx.exception = re
12369
13577
  self._errHandler.reportError(self, re)
@@ -12460,11 +13668,23 @@ class Parser(Parser):
12460
13668
  self.enterOuterAlt(localctx, 1)
12461
13669
  self.state = 1616
12462
13670
  _la = self._input.LA(1)
12463
- if not (((((_la - 213)) & ~0x3f) == 0 and ((1 << (_la - 213)) & (
12464
- (1 << (Parser.NON_NULL - 213)) | (1 << (Parser.NON_ZERO - 213)) | (
12465
- 1 << (Parser.PARTIAL_NULL - 213)) | (1 << (Parser.PARTIAL_ZERO - 213)) | (
12466
- 1 << (Parser.ALWAYS_NULL - 213)) | (
12467
- 1 << (Parser.ALWAYS_ZERO - 213)))) != 0)):
13671
+ if not (
13672
+ (
13673
+ (((_la - 213)) & ~0x3F) == 0
13674
+ and (
13675
+ (1 << (_la - 213))
13676
+ & (
13677
+ (1 << (Parser.NON_NULL - 213))
13678
+ | (1 << (Parser.NON_ZERO - 213))
13679
+ | (1 << (Parser.PARTIAL_NULL - 213))
13680
+ | (1 << (Parser.PARTIAL_ZERO - 213))
13681
+ | (1 << (Parser.ALWAYS_NULL - 213))
13682
+ | (1 << (Parser.ALWAYS_ZERO - 213))
13683
+ )
13684
+ )
13685
+ != 0
13686
+ )
13687
+ ):
12468
13688
  self._errHandler.recoverInline(self)
12469
13689
  else:
12470
13690
  self._errHandler.reportMatch(self)
@@ -12852,7 +14072,6 @@ class Parser(Parser):
12852
14072
  self.state = 1644
12853
14073
  self.match(Parser.IDENTIFIER)
12854
14074
 
12855
-
12856
14075
  except RecognitionException as re:
12857
14076
  localctx.exception = re
12858
14077
  self._errHandler.reportError(self, re)
@@ -13047,9 +14266,23 @@ class Parser(Parser):
13047
14266
  self.enterOuterAlt(localctx, 1)
13048
14267
  self.state = 1664
13049
14268
  _la = self._input.LA(1)
13050
- if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & (
13051
- (1 << Parser.EQ) | (1 << Parser.LT) | (1 << Parser.MT) | (1 << Parser.ME) | (
13052
- 1 << Parser.NEQ) | (1 << Parser.LE))) != 0)):
14269
+ if not (
14270
+ (
14271
+ ((_la) & ~0x3F) == 0
14272
+ and (
14273
+ (1 << _la)
14274
+ & (
14275
+ (1 << Parser.EQ)
14276
+ | (1 << Parser.LT)
14277
+ | (1 << Parser.MT)
14278
+ | (1 << Parser.ME)
14279
+ | (1 << Parser.NEQ)
14280
+ | (1 << Parser.LE)
14281
+ )
14282
+ )
14283
+ != 0
14284
+ )
14285
+ ):
13053
14286
  self._errHandler.recoverInline(self)
13054
14287
  else:
13055
14288
  self._errHandler.reportMatch(self)
@@ -13091,24 +14324,80 @@ class Parser(Parser):
13091
14324
  self.state = 1668
13092
14325
  self._errHandler.sync(self)
13093
14326
  token = self._input.LA(1)
13094
- if token in [Parser.LPAREN, Parser.PLUS, Parser.MINUS, Parser.EVAL, Parser.IF,
13095
- Parser.CURRENT_DATE, Parser.NOT, Parser.BETWEEN, Parser.NULL_CONSTANT,
13096
- Parser.ISNULL, Parser.UNION, Parser.SYMDIFF, Parser.INTERSECT,
13097
- Parser.CHECK, Parser.EXISTS_IN, Parser.MIN, Parser.MAX, Parser.ABS,
13098
- Parser.LN, Parser.LOG, Parser.TRUNC, Parser.ROUND, Parser.POWER,
13099
- Parser.MOD, Parser.LEN, Parser.TRIM, Parser.UCASE, Parser.LCASE,
13100
- Parser.SUBSTR, Parser.SUM, Parser.AVG, Parser.MEDIAN, Parser.COUNT,
13101
- Parser.EXP, Parser.CHARSET_MATCH, Parser.NVL, Parser.HIERARCHY,
13102
- Parser.LTRIM, Parser.RTRIM, Parser.INSTR, Parser.REPLACE, Parser.CEIL,
13103
- Parser.FLOOR, Parser.SQRT, Parser.SETDIFF, Parser.STDDEV_POP,
13104
- Parser.STDDEV_SAMP, Parser.VAR_POP, Parser.VAR_SAMP, Parser.FIRST_VALUE,
13105
- Parser.LAST_VALUE, Parser.LAG, Parser.LEAD, Parser.RATIO_TO_REPORT,
13106
- Parser.FILL_TIME_SERIES, Parser.FLOW_TO_STOCK, Parser.STOCK_TO_FLOW,
13107
- Parser.TIMESHIFT, Parser.INNER_JOIN, Parser.LEFT_JOIN, Parser.CROSS_JOIN,
13108
- Parser.FULL_JOIN, Parser.PERIOD_INDICATOR, Parser.TIME_AGG, Parser.CAST,
13109
- Parser.CHECK_DATAPOINT, Parser.CHECK_HIERARCHY, Parser.INTEGER_CONSTANT,
13110
- Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT, Parser.STRING_CONSTANT,
13111
- Parser.IDENTIFIER]:
14327
+ if token in [
14328
+ Parser.LPAREN,
14329
+ Parser.PLUS,
14330
+ Parser.MINUS,
14331
+ Parser.EVAL,
14332
+ Parser.IF,
14333
+ Parser.CURRENT_DATE,
14334
+ Parser.NOT,
14335
+ Parser.BETWEEN,
14336
+ Parser.NULL_CONSTANT,
14337
+ Parser.ISNULL,
14338
+ Parser.UNION,
14339
+ Parser.SYMDIFF,
14340
+ Parser.INTERSECT,
14341
+ Parser.CHECK,
14342
+ Parser.EXISTS_IN,
14343
+ Parser.MIN,
14344
+ Parser.MAX,
14345
+ Parser.ABS,
14346
+ Parser.LN,
14347
+ Parser.LOG,
14348
+ Parser.TRUNC,
14349
+ Parser.ROUND,
14350
+ Parser.POWER,
14351
+ Parser.MOD,
14352
+ Parser.LEN,
14353
+ Parser.TRIM,
14354
+ Parser.UCASE,
14355
+ Parser.LCASE,
14356
+ Parser.SUBSTR,
14357
+ Parser.SUM,
14358
+ Parser.AVG,
14359
+ Parser.MEDIAN,
14360
+ Parser.COUNT,
14361
+ Parser.EXP,
14362
+ Parser.CHARSET_MATCH,
14363
+ Parser.NVL,
14364
+ Parser.HIERARCHY,
14365
+ Parser.LTRIM,
14366
+ Parser.RTRIM,
14367
+ Parser.INSTR,
14368
+ Parser.REPLACE,
14369
+ Parser.CEIL,
14370
+ Parser.FLOOR,
14371
+ Parser.SQRT,
14372
+ Parser.SETDIFF,
14373
+ Parser.STDDEV_POP,
14374
+ Parser.STDDEV_SAMP,
14375
+ Parser.VAR_POP,
14376
+ Parser.VAR_SAMP,
14377
+ Parser.FIRST_VALUE,
14378
+ Parser.LAST_VALUE,
14379
+ Parser.LAG,
14380
+ Parser.LEAD,
14381
+ Parser.RATIO_TO_REPORT,
14382
+ Parser.FILL_TIME_SERIES,
14383
+ Parser.FLOW_TO_STOCK,
14384
+ Parser.STOCK_TO_FLOW,
14385
+ Parser.TIMESHIFT,
14386
+ Parser.INNER_JOIN,
14387
+ Parser.LEFT_JOIN,
14388
+ Parser.CROSS_JOIN,
14389
+ Parser.FULL_JOIN,
14390
+ Parser.PERIOD_INDICATOR,
14391
+ Parser.TIME_AGG,
14392
+ Parser.CAST,
14393
+ Parser.CHECK_DATAPOINT,
14394
+ Parser.CHECK_HIERARCHY,
14395
+ Parser.INTEGER_CONSTANT,
14396
+ Parser.NUMBER_CONSTANT,
14397
+ Parser.BOOLEAN_CONSTANT,
14398
+ Parser.STRING_CONSTANT,
14399
+ Parser.IDENTIFIER,
14400
+ ]:
13112
14401
  self.enterOuterAlt(localctx, 1)
13113
14402
  self.state = 1666
13114
14403
  self.expr(0)
@@ -13158,20 +14447,68 @@ class Parser(Parser):
13158
14447
  self.state = 1672
13159
14448
  self._errHandler.sync(self)
13160
14449
  token = self._input.LA(1)
13161
- if token in [Parser.LPAREN, Parser.PLUS, Parser.MINUS, Parser.EVAL, Parser.IF,
13162
- Parser.CURRENT_DATE, Parser.NOT, Parser.BETWEEN, Parser.NULL_CONSTANT,
13163
- Parser.ISNULL, Parser.RANK, Parser.MIN, Parser.MAX, Parser.ABS, Parser.LN,
13164
- Parser.LOG, Parser.TRUNC, Parser.ROUND, Parser.POWER, Parser.MOD,
13165
- Parser.LEN, Parser.TRIM, Parser.UCASE, Parser.LCASE, Parser.SUBSTR,
13166
- Parser.SUM, Parser.AVG, Parser.MEDIAN, Parser.COUNT, Parser.EXP,
13167
- Parser.CHARSET_MATCH, Parser.NVL, Parser.LTRIM, Parser.RTRIM, Parser.INSTR,
13168
- Parser.REPLACE, Parser.CEIL, Parser.FLOOR, Parser.SQRT, Parser.STDDEV_POP,
13169
- Parser.STDDEV_SAMP, Parser.VAR_POP, Parser.VAR_SAMP, Parser.FIRST_VALUE,
13170
- Parser.LAST_VALUE, Parser.LAG, Parser.LEAD, Parser.RATIO_TO_REPORT,
13171
- Parser.FILL_TIME_SERIES, Parser.FLOW_TO_STOCK, Parser.STOCK_TO_FLOW,
13172
- Parser.TIMESHIFT, Parser.PERIOD_INDICATOR, Parser.TIME_AGG, Parser.CAST,
13173
- Parser.INTEGER_CONSTANT, Parser.NUMBER_CONSTANT, Parser.BOOLEAN_CONSTANT,
13174
- Parser.STRING_CONSTANT, Parser.IDENTIFIER]:
14450
+ if token in [
14451
+ Parser.LPAREN,
14452
+ Parser.PLUS,
14453
+ Parser.MINUS,
14454
+ Parser.EVAL,
14455
+ Parser.IF,
14456
+ Parser.CURRENT_DATE,
14457
+ Parser.NOT,
14458
+ Parser.BETWEEN,
14459
+ Parser.NULL_CONSTANT,
14460
+ Parser.ISNULL,
14461
+ Parser.RANK,
14462
+ Parser.MIN,
14463
+ Parser.MAX,
14464
+ Parser.ABS,
14465
+ Parser.LN,
14466
+ Parser.LOG,
14467
+ Parser.TRUNC,
14468
+ Parser.ROUND,
14469
+ Parser.POWER,
14470
+ Parser.MOD,
14471
+ Parser.LEN,
14472
+ Parser.TRIM,
14473
+ Parser.UCASE,
14474
+ Parser.LCASE,
14475
+ Parser.SUBSTR,
14476
+ Parser.SUM,
14477
+ Parser.AVG,
14478
+ Parser.MEDIAN,
14479
+ Parser.COUNT,
14480
+ Parser.EXP,
14481
+ Parser.CHARSET_MATCH,
14482
+ Parser.NVL,
14483
+ Parser.LTRIM,
14484
+ Parser.RTRIM,
14485
+ Parser.INSTR,
14486
+ Parser.REPLACE,
14487
+ Parser.CEIL,
14488
+ Parser.FLOOR,
14489
+ Parser.SQRT,
14490
+ Parser.STDDEV_POP,
14491
+ Parser.STDDEV_SAMP,
14492
+ Parser.VAR_POP,
14493
+ Parser.VAR_SAMP,
14494
+ Parser.FIRST_VALUE,
14495
+ Parser.LAST_VALUE,
14496
+ Parser.LAG,
14497
+ Parser.LEAD,
14498
+ Parser.RATIO_TO_REPORT,
14499
+ Parser.FILL_TIME_SERIES,
14500
+ Parser.FLOW_TO_STOCK,
14501
+ Parser.STOCK_TO_FLOW,
14502
+ Parser.TIMESHIFT,
14503
+ Parser.PERIOD_INDICATOR,
14504
+ Parser.TIME_AGG,
14505
+ Parser.CAST,
14506
+ Parser.INTEGER_CONSTANT,
14507
+ Parser.NUMBER_CONSTANT,
14508
+ Parser.BOOLEAN_CONSTANT,
14509
+ Parser.STRING_CONSTANT,
14510
+ Parser.IDENTIFIER,
14511
+ ]:
13175
14512
  self.enterOuterAlt(localctx, 1)
13176
14513
  self.state = 1670
13177
14514
  self.exprComponent(0)
@@ -13446,11 +14783,22 @@ class Parser(Parser):
13446
14783
  self.enterOuterAlt(localctx, 1)
13447
14784
  self.state = 1690
13448
14785
  _la = self._input.LA(1)
13449
- if not (_la == Parser.NULL_CONSTANT or ((((_la - 229)) & ~0x3f) == 0 and (
13450
- (1 << (_la - 229)) & ((1 << (Parser.INTEGER_CONSTANT - 229)) | (
13451
- 1 << (Parser.NUMBER_CONSTANT - 229)) | (
13452
- 1 << (Parser.BOOLEAN_CONSTANT - 229)) | (
13453
- 1 << (Parser.STRING_CONSTANT - 229)))) != 0)):
14786
+ if not (
14787
+ _la == Parser.NULL_CONSTANT
14788
+ or (
14789
+ (((_la - 229)) & ~0x3F) == 0
14790
+ and (
14791
+ (1 << (_la - 229))
14792
+ & (
14793
+ (1 << (Parser.INTEGER_CONSTANT - 229))
14794
+ | (1 << (Parser.NUMBER_CONSTANT - 229))
14795
+ | (1 << (Parser.BOOLEAN_CONSTANT - 229))
14796
+ | (1 << (Parser.STRING_CONSTANT - 229))
14797
+ )
14798
+ )
14799
+ != 0
14800
+ )
14801
+ ):
13454
14802
  self._errHandler.recoverInline(self)
13455
14803
  else:
13456
14804
  self._errHandler.reportMatch(self)
@@ -13514,12 +14862,26 @@ class Parser(Parser):
13514
14862
  self.enterOuterAlt(localctx, 1)
13515
14863
  self.state = 1692
13516
14864
  _la = self._input.LA(1)
13517
- if not (((((_la - 156)) & ~0x3f) == 0 and ((1 << (_la - 156)) & (
13518
- (1 << (Parser.BOOLEAN - 156)) | (1 << (Parser.DATE - 156)) | (
13519
- 1 << (Parser.TIME_PERIOD - 156)) | (1 << (Parser.NUMBER - 156)) | (
13520
- 1 << (Parser.STRING - 156)) | (1 << (Parser.TIME - 156)) | (
13521
- 1 << (Parser.INTEGER - 156)) | (
13522
- 1 << (Parser.DURATION - 156)))) != 0) or _la == Parser.SCALAR):
14865
+ if not (
14866
+ (
14867
+ (((_la - 156)) & ~0x3F) == 0
14868
+ and (
14869
+ (1 << (_la - 156))
14870
+ & (
14871
+ (1 << (Parser.BOOLEAN - 156))
14872
+ | (1 << (Parser.DATE - 156))
14873
+ | (1 << (Parser.TIME_PERIOD - 156))
14874
+ | (1 << (Parser.NUMBER - 156))
14875
+ | (1 << (Parser.STRING - 156))
14876
+ | (1 << (Parser.TIME - 156))
14877
+ | (1 << (Parser.INTEGER - 156))
14878
+ | (1 << (Parser.DURATION - 156))
14879
+ )
14880
+ )
14881
+ != 0
14882
+ )
14883
+ or _la == Parser.SCALAR
14884
+ ):
13523
14885
  self._errHandler.recoverInline(self)
13524
14886
  else:
13525
14887
  self._errHandler.reportMatch(self)